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(canvas): media upload tool/menus, better handling of zoom to fit (#8144)

Seamusd4b5336edc52
diff --git a/apps/web/src/features/block-canvas/README.md b/apps/web/src/features/block-canvas/README.md
index 3357b4f5d6..e173e9a15e 100644
--- a/apps/web/src/features/block-canvas/README.md
+++ b/apps/web/src/features/block-canvas/README.md
@@ -35,7 +35,8 @@ The floating top toolbar uses the shared `Toolbar` and Phosphor icons for drawin
and inserting media, document cards, and embeds. Tooltips show each tool's shortcut.
Zoom, reset-to-100%, fit, undo, and redo live at the bottom-left. Adjacent controls
toggle floating properties and layers panels.
-Fit Scene uses the current viewport dimensions, centers all scene geometry and
+Fit Scene and menu/keyboard zoom use the full canvas viewport without subtracting
+floating panels. Fit Scene centers all scene geometry and
zooms in or out to leave 100 screen pixels per side on the first axis to fill.
Camera zoom limits still apply; padding decreases for small embedded viewports.
Ctrl/Meta-wheel zoom is pointer-anchored, with a continuous 0.002 exponential rate
@@ -74,6 +75,7 @@ uses full opacity. Other style choices and existing shapes are preserved.
| Move horizontally / vertically | Hold Shift while dragging; follows the dominant world axis |
| Select inside a group | Cmd/Ctrl-click |
| Copy / cut / paste | Cmd/Ctrl+C / X / V |
+| Paste in place | Shift+Cmd/Ctrl+V |
| Duplicate | Cmd/Ctrl+D, or Option/Alt-drag |
| Select all | Cmd/Ctrl+A |
| Nudge | Arrows: one snap unit; Shift+arrows: ten snap units |
@@ -89,7 +91,11 @@ Native clipboard events own the actual copy/cut/paste keystrokes; proxied Macro
commands expose those actions in the command UI without double handling.
Clipboard context-menu actions use the browser clipboard API and report denied
access. Fragments include whole selected subtrees, fresh IDs on insertion, stable
-relative order and world placement. Pasting repeatedly offsets by another 24 units.
+relative order and world placement. Copies include the source canvas ID: pasting
+within that canvas offsets each repeat by another 24 units. Fragments from another
+canvas (or without source metadata), including Excalidraw imports, are centered as
+a whole in the current viewport, accounting for pan and zoom. Shift+Cmd/Ctrl+V
+and **Paste in place** preserve original world coordinates without grid snapping.
Canvas Next fragments preserve rich text. Plain text and HTML pasted onto the canvas
create a wrapped text shape; pasting inside the editor belongs to Lexical. Image
clipboard data uploads through the media adapter. Legacy Canvas clipboard format
@@ -314,7 +320,12 @@ sized, fitted within 640 × 480 world units, and inserted in one undo step per b
Uploading/loading is host-owned; only stable static-file or document references
enter the scene. Reset/unmount invalidates pending insertion. Saved Canvas Next
documents retain stable uploaded references;
-uploads use the existing static file service. Existing workspace file selection
+uploads use the existing static file service. Pasted and dropped files show local
+blob previews at their insertion positions while uploads finish. These previews
+are not editable scene items; failures, reset, and unmount release their URLs.
+Image nodes reserve their full bounds with the shared `skeleton-shimmer` and
+`bg-skeleton` classes until the browser loads the image, including in read-only
+canvases. Existing workspace file selection
does not create a new file.
Image/video shape definitions own validation, bounds, hit testing and resizing in
@@ -335,12 +346,40 @@ preview contents, and upload state are never stored in core. SVG-to-editable-sha
conversion is not part of this checkpoint; SVG files can be inserted as images.
-New embed insertion is not currently exposed in the toolbar. An existing document
-card can switch between preview and embed in the inspector. Double-click
-an embed or choose Interact to enter; Done, Escape, or a click elsewhere on this
-canvas returns input to the outer canvas. Resizing changes the editor viewport.
+The drawing toolbar’s paperclip **Attach** button (shortcut hint `I`) opens a
+standard dropdown for Media, Upload media, and Reference. Its pickers appear
+above the toolbar and place attachments at the canvas center.
+
+Press `I` with the canvas focused to open a radial menu of separate floating rectangular buttons centered at the pointer
+(or the viewport center before a pointer location is available). **Media** opens
+the current searchable media picker; **Upload media** opens the OS file picker
+directly; **Reference** opens the searchable document picker. The pickers reuse
+the mentions menu's quick-access source, paging, icons, and rows. Media accepts
+workspace images/videos or local uploads; references create document preview cards.
+The full viewport around the center is divided into equal directional slices. Moving into
+a slice highlights its button and matching ring arc; clicking anywhere outside the buttons
+activates the highlighted slice instead of dismissing the menu. The center remains neutral. Arrow keys or Ctrl+J/K
+navigate; Enter selects and Escape closes. Scrolled results
+keep the same inset as the menu padding. The media picker includes a dashed drop
+area and Add files button for local images/videos.
+Insertion keeps the world position captured when the menu opened, even under
+pan/zoom. New embed insertion and preview-to-embed conversion are unavailable.
+Existing embeds can be converted to previews in the inspector. Double-click an
+existing embed or choose Interact to enter; Done, Escape, or a click elsewhere on
+this canvas returns input to the outer canvas. Resizing changes the editor viewport.
The embedded block stays mounted when entering/leaving interaction mode.
+Document cards participate in the shared entity-mention reference system. The
+serialized save adapter registers one mention per target document and stores its
+ID in optional `referenceTracking` file metadata. Duplicate cards share a mention;
+deleting the last card removes it after the scene saves. Undo/redo reconciles the
+saved targets. Failed saves retain created IDs for retry, and pending deletions
+survive reload. Source ownership prevents copied canvases from deleting mentions
+belonging to the original. Existing untracked cards register on the next edit;
+opening a canvas does not write references. Tracking follows the shared mention
+tracking flag. File saving and mention creation are separate server operations,
+so an interrupted creation before the file save cannot be recovered transactionally.
+
`block-embed-adapter.tsx` mounts the existing unmanaged block loader with its own
panel handle, toolbar, and hotkey scope. The existing editor owns permissions and
sync: edits inside an embed save to that referenced file independently of the outer
diff --git a/apps/web/src/features/block-canvas/canvas-next-document.tsx b/apps/web/src/features/block-canvas/canvas-next-document.tsx
index 702a96c335..9d12e836e0 100644
--- a/apps/web/src/features/block-canvas/canvas-next-document.tsx
+++ b/apps/web/src/features/block-canvas/canvas-next-document.tsx
@@ -80,6 +80,7 @@ export default function CanvasNextDocument(
<Show when={!savedLocation.loading}>
<CanvasAncestry.Provider value={[...ancestors, documentId]}>
<CanvasNextEditor
+ documentId={documentId}
initial={initial}
canEdit={props.canEdit}
isEmbedded={props.isNested}
@@ -89,7 +90,7 @@ export default function CanvasNextDocument(
const saving = createDocumentPersistence(
current,
initial,
- canvasDocumentSource(documentId, canEdit)
+ canvasDocumentSource(documentId, canEdit, initial)
);
setPersistence(saving);
props.registerMethods?.({
diff --git a/apps/web/src/features/block-canvas/canvas-next.tsx b/apps/web/src/features/block-canvas/canvas-next.tsx
index 8404ad9de0..7486e6f377 100644
--- a/apps/web/src/features/block-canvas/canvas-next.tsx
+++ b/apps/web/src/features/block-canvas/canvas-next.tsx
@@ -1,6 +1,7 @@
import { useSplitLayout } from '@components/app/split-layout/layout';
+import { useMacroMentionLinkResolver } from '@components/app/split-layout/split-router/mention-links';
import { StaticMarkdownContext } from '@core/component/LexicalMarkdown/component/core/StaticMarkdown';
-import { parseMacroAppUrl } from '@core/component/LexicalMarkdown/plugins';
+import { resolvePastedMacroAppUrl } from '@core/component/LexicalMarkdown/plugins/text-paste/textPastePlugin';
import {
fileTypeToBlockName,
resolveBlockAlias,
@@ -16,6 +17,7 @@ import type { CanvasFile } from './core/document-format';
import { registerCanvasNextHotkeys } from './hotkeys';
import { createAssetState } from './primitives/create-asset-state';
import { createCanvasState } from './primitives/create-canvas-state';
+import { createCanvasInsertState } from './primitives/create-insert-state';
import { importTextClipboard } from './primitives/text-lexical';
import { canvasAssetSource } from './queries/assets';
import { CanvasReadOnlyView } from './views/canvas-read-only-view';
@@ -23,6 +25,7 @@ import { CanvasView } from './views/canvas-view';
import { createCanvasTextMeasurer } from './views/text-content';
export function CanvasNextEditor(props: {
+ documentId: string;
initial: CanvasFile;
canEdit: boolean;
isEmbedded?: boolean;
@@ -46,6 +49,7 @@ export function CanvasNextEditor(props: {
}
>
<EditableCanvasNext
+ documentId={props.documentId}
editor={editor}
measureText={measurement.measure}
fitOnLoad={props.fitOnLoad}
@@ -60,6 +64,7 @@ export function CanvasNextEditor(props: {
}
function EditableCanvasNext(props: {
+ documentId: string;
editor: GraphicsEditor;
measureText: TextMeasurer;
fitOnLoad?: boolean;
@@ -69,7 +74,9 @@ function EditableCanvasNext(props: {
const editor = props.editor;
const state = createCanvasState(editor, props.measureText);
const assets = createAssetState(state, canvasAssetSource);
+ const insert = createCanvasInsertState(editor.getCamera);
const { openWithSplit } = useSplitLayout();
+ const resolveAppLink = useMacroMentionLinkResolver();
let viewport: HTMLElement | undefined;
const center = () =>
screenToWorld(editor.getCamera(), {
@@ -80,8 +87,8 @@ function EditableCanvasNext(props: {
editor,
state.setNotice,
(text, html) => {
- const link = parseMacroAppUrl(text);
- if (link.isValid && link.id && link.block) {
+ const link = resolvePastedMacroAppUrl(text, resolveAppLink);
+ if (link?.id && link.block) {
assets.document(
{ id: link.id, name: 'Document', fileType: link.block },
center()
@@ -93,10 +100,17 @@ function EditableCanvasNext(props: {
},
(files) => {
void assets.files(files, center());
- }
+ },
+ { canvasId: props.documentId, center }
);
const [attachScope, scopeId] = useHotkeyDOMScope('canvas-next');
- registerCanvasNextHotkeys(scopeId, state, clipboard, props.canEdit);
+ registerCanvasNextHotkeys(
+ scopeId,
+ state,
+ clipboard,
+ props.canEdit,
+ insert.open
+ );
props.onFinishReady(state.text.finish);
onCleanup(() => {
state.text.finish();
@@ -117,6 +131,7 @@ function EditableCanvasNext(props: {
scopeId={scopeId}
embedView={CanvasBlockEmbed}
assets={assets}
+ insert={insert}
onViewport={(element) => {
viewport = element;
}}
diff --git a/apps/web/src/features/block-canvas/clipboard.test.ts b/apps/web/src/features/block-canvas/clipboard.test.ts
index 5b33f89799..4e36d9b6d9 100644
--- a/apps/web/src/features/block-canvas/clipboard.test.ts
+++ b/apps/web/src/features/block-canvas/clipboard.test.ts
@@ -1,7 +1,11 @@
import {
+ copyFragment,
createGraphicsEditor,
drawableIds,
+ screenToWorld,
+ selectAllCommand,
setShapeLabelCommand,
+ worldBounds,
} from '@macro-inc/graphics';
import { afterEach, expect, it, vi } from 'vitest';
import { createCanvasClipboard } from './clipboard';
@@ -14,13 +18,20 @@ afterEach(() => {
vi.unstubAllGlobals();
});
-function setup() {
+function setup(canvasId = 'canvas-a') {
const editor = createGraphicsEditor(createCanvasNextScene());
const host = document.createElement('div');
const input = document.createElement('input');
host.append(input);
const notify = vi.fn();
- const clipboard = createCanvasClipboard(editor, notify);
+ const center = () => screenToWorld(editor.getCamera(), { x: 400, y: 300 });
+ const clipboard = createCanvasClipboard(
+ editor,
+ notify,
+ undefined,
+ undefined,
+ { canvasId, center }
+ );
cleanup.push(clipboard.attach(host), editor.dispose);
const data = new Map<string, string>();
const event = (type: string, target: HTMLElement = host) => {
@@ -34,9 +45,139 @@ function setup() {
target.dispatchEvent(event);
return event;
};
- return { editor, input, host, data, event, clipboard, notify };
+ return { editor, input, host, data, event, clipboard, notify, center };
+}
+
+function selectedBounds(editor: ReturnType<typeof createGraphicsEditor>) {
+ const fragment = copyFragment(
+ editor.document,
+ editor.getSession().selectedIds
+ )!;
+ return worldBounds(fragment.scene, fragment.scene.rootId);
}
+it('centers cross-canvas selections in the current viewport, preserving their relative layout', () => {
+ const source = setup('source');
+ source.editor.execute(selectAllCommand, undefined);
+ const original = selectedBounds(source.editor);
+ source.event('copy');
+ const target = setup('target');
+ target.editor.zoomAt({ x: 0, y: 0 }, 2);
+ target.editor.panBy({ x: 1000, y: -500 });
+ target.editor.setSnapUnit(100);
+ target.data.set('text/plain', source.data.get('text/plain')!);
+ target.event('paste');
+ const bounds = selectedBounds(target.editor);
+ expect(bounds.width).toBe(original.width);
+ expect(bounds.height).toBe(original.height);
+ expect(bounds.x + bounds.width / 2).toBe(target.center().x);
+ expect(bounds.y + bounds.height / 2).toBe(target.center().y);
+ target.event('paste');
+ expect(selectedBounds(target.editor)).toEqual(bounds);
+ target.editor.undo();
+ expect(drawableIds(target.editor.document)).toHaveLength(6);
+ target.editor.redo();
+ expect(drawableIds(target.editor.document)).toHaveLength(9);
+});
+
+it('recognizes copies from another instance of the same canvas', () => {
+ const source = setup();
+ source.editor.select('welcome-rectangle');
+ source.event('copy');
+ const target = setup();
+ target.data.set('text/plain', source.data.get('text/plain')!);
+ target.event('paste');
+ expect(selectedBounds(target.editor)).toMatchObject({ x: 124, y: 124 });
+});
+
+it('centers old fragments without source metadata as external spatial data', () => {
+ const { editor, event, data, center } = setup();
+ data.set(
+ 'text/plain',
+ JSON.stringify(copyFragment(editor.document, ['welcome-small']))
+ );
+ event('paste');
+ const bounds = selectedBounds(editor);
+ expect(bounds.x + bounds.width / 2).toBe(center().x);
+ expect(bounds.y + bounds.height / 2).toBe(center().y);
+});
+
+it('Shift-pastes exactly in place without snapping or advancing the same-canvas offset', () => {
+ const { editor, event, host } = setup();
+ editor.select('welcome-small');
+ const original = selectedBounds(editor);
+ event('copy');
+ event('paste');
+ editor.setSnapUnit(100);
+ host.dispatchEvent(
+ new KeyboardEvent('keydown', { key: 'v', metaKey: true, shiftKey: true })
+ );
+ event('paste');
+ expect(selectedBounds(editor)).toEqual(original);
+ host.dispatchEvent(
+ new KeyboardEvent('keyup', { key: 'Shift', shiftKey: false })
+ );
+ editor.setSnapUnit(undefined);
+ event('paste');
+ expect(selectedBounds(editor)).toMatchObject({
+ x: original.x + 48,
+ y: original.y + 48,
+ });
+});
+
+it('centers grouped Excalidraw shapes and supports paste in place through the clipboard API', async () => {
+ const { editor, data, event, center, clipboard } = setup();
+ const text = JSON.stringify({
+ type: 'excalidraw/clipboard',
+ elements: [
+ {
+ id: 'a',
+ type: 'rectangle',
+ x: 101,
+ y: 203,
+ width: 100,
+ height: 80,
+ angle: Math.PI / 4,
+ groupIds: ['group'],
+ },
+ {
+ id: 'b',
+ type: 'ellipse',
+ x: 401,
+ y: 503,
+ width: 100,
+ height: 80,
+ groupIds: ['group'],
+ },
+ ],
+ });
+ data.set('text/plain', text);
+ event('paste');
+ const centered = selectedBounds(editor);
+ expect(centered.x + centered.width / 2).toBeCloseTo(center().x);
+ expect(centered.y + centered.height / 2).toBeCloseTo(center().y);
+ vi.stubGlobal('navigator', { clipboard: { readText: async () => text } });
+ editor.setSnapUnit(100);
+ await clipboard.paste(true);
+ const inPlace = selectedBounds(editor);
+ expect(inPlace.width).toBeCloseTo(centered.width);
+ expect(inPlace.height).toBeCloseTo(centered.height);
+ expect(inPlace.x).toBeCloseTo(151 - 90 / Math.sqrt(2));
+ expect(inPlace.y).toBeCloseTo(243 - 90 / Math.sqrt(2));
+});
+
+it('clears held modifiers when the canvas loses focus', () => {
+ const { editor, event, host } = setup();
+ editor.select('welcome-rectangle');
+ event('copy');
+ host.dispatchEvent(
+ new KeyboardEvent('keydown', { key: 'Shift', shiftKey: true })
+ );
+ host.dispatchEvent(new FocusEvent('focusout'));
+ event('paste');
+ expect(selectedBounds(editor)).toMatchObject({ x: 124, y: 124 });
+});
+
it('copies/cuts/pastes native events, offsets repeated pastes, and undoes the whole fragment', () => {
const { editor, data, event } = setup();
editor.select('welcome-rectangle');
diff --git a/apps/web/src/features/block-canvas/clipboard.ts b/apps/web/src/features/block-canvas/clipboard.ts
index 5f9fe2dc26..1d1f2454e0 100644
--- a/apps/web/src/features/block-canvas/clipboard.ts
+++ b/apps/web/src/features/block-canvas/clipboard.ts
@@ -2,13 +2,22 @@ import {
copyFragment,
type GraphicsEditor,
type GraphicsFragment,
+ type Point,
parseFragment,
pasteCommand,
+ screenToWorld,
+ worldBounds,
} from '@macro-inc/graphics';
import { importExcalidraw } from './core/excalidraw';
import { validCanvasTextDocument } from './core/text-codec';
const mime = 'application/x-macro-graphics';
+// Exact placement must not be shifted by the destination canvas's snap grid.
+const pasteAtPositionCommand: typeof pasteCommand = {
+ ...pasteCommand,
+ apply: (context, payload) =>
+ pasteCommand.apply({ ...context, snapUnit: undefined }, payload),
+};
const editingText = (target: EventTarget | null) =>
target instanceof Element &&
!!target.closest(
@@ -20,8 +29,11 @@ export function createCanvasClipboard(
editor: GraphicsEditor,
notify: (message: string) => void,
pasteText?: (text: string, html?: string) => void,
- pasteFiles?: (files: File[]) => void
+ pasteFiles?: (files: File[]) => void,
+ placement?: { canvasId: string; center: () => Point }
) {
+ const canvasId = placement?.canvasId ?? crypto.randomUUID();
+ let viewport: HTMLElement | undefined;
let pastedText = '',
pasteCount = 0;
const serialize = () => {
@@ -29,32 +41,64 @@ export function createCanvasClipboard(
editor.document,
editor.getSession().selectedIds
);
- return fragment ? JSON.stringify(fragment) : undefined;
+ return fragment
+ ? JSON.stringify({ ...fragment, sourceCanvasId: canvasId })
+ : undefined;
};
- const insert = (fragment: GraphicsFragment, text: string) => {
+ const insert = (
+ fragment: GraphicsFragment,
+ text: string,
+ sameCanvas: boolean,
+ inPlace: boolean
+ ) => {
if (!validCanvasTextDocument(fragment.scene)) {
notify('Clipboard has invalid Canvas Next text');
return false;
}
- pasteCount = text === pastedText ? pasteCount + 1 : 1;
- pastedText = text;
- editor.execute(pasteCommand, {
- fragment,
- createId: () => crypto.randomUUID(),
- offset: { x: 24 * pasteCount, y: 24 * pasteCount },
- });
+ let offset: Point = { x: 0, y: 0 };
+ if (!inPlace && sameCanvas) {
+ pasteCount = text === pastedText ? pasteCount + 1 : 1;
+ pastedText = text;
+ offset = { x: 24 * pasteCount, y: 24 * pasteCount };
+ } else if (!inPlace) {
+ const center =
+ placement?.center() ??
+ screenToWorld(editor.getCamera(), {
+ x: (viewport?.clientWidth ?? 0) / 2,
+ y: (viewport?.clientHeight ?? 0) / 2,
+ });
+ const bounds = worldBounds(fragment.scene, fragment.scene.rootId);
+ offset = {
+ x: center.x - (bounds.x + bounds.width / 2),
+ y: center.y - (bounds.y + bounds.height / 2),
+ };
+ }
+ editor.execute(
+ sameCanvas && !inPlace ? pasteCommand : pasteAtPositionCommand,
+ {
+ fragment,
+ createId: () => crypto.randomUUID(),
+ offset,
+ }
+ );
return true;
};
- const paste = (text: string, html?: string) => {
+ const paste = (text: string, html?: string, inPlace = false) => {
const fragment = parseFragment(text);
if (fragment) {
- const pasted = insert(fragment, text);
+ const metadata: { sourceCanvasId?: unknown } = JSON.parse(text);
+ const pasted = insert(
+ fragment,
+ text,
+ metadata.sourceCanvasId === canvasId,
+ inPlace
+ );
if (pasted) notify('Pasted selection');
return pasted;
}
const excalidraw = importExcalidraw(text);
if (excalidraw) {
- const pasted = insert(excalidraw.fragment, text);
+ const pasted = insert(excalidraw.fragment, text, false, inPlace);
if (pasted) notify(excalidrawNotice(excalidraw));
return pasted;
}
@@ -89,7 +133,7 @@ export function createCanvasClipboard(
return {
copy: () => copy(),
cut: () => copy(true),
- async paste() {
+ async paste(inPlace = false) {
try {
if (pasteFiles && navigator.clipboard.read) {
const items = await navigator.clipboard.read();
@@ -116,13 +160,22 @@ export function createCanvasClipboard(
}
}
if (files.length) pasteFiles(files);
- else paste(text, html);
- } else paste(await navigator.clipboard.readText());
+ else paste(text, html, inPlace);
+ } else paste(await navigator.clipboard.readText(), undefined, inPlace);
} catch {
notify('Clipboard permission denied. Use the paste keyboard shortcut.');
}
},
attach(element: HTMLElement) {
+ viewport = element;
+ // ClipboardEvent has no modifier keys; capture them from native keyboard events.
+ let shiftHeld = false;
+ const modifiers = (event: KeyboardEvent) => {
+ shiftHeld = event.shiftKey;
+ };
+ const resetModifiers = () => {
+ shiftHeld = false;
+ };
const write = (event: ClipboardEvent) => {
if (
event.defaultPrevented ||
@@ -158,7 +211,8 @@ export function createCanvasClipboard(
paste(
event.clipboardData.getData(mime) ||
event.clipboardData.getData('text/plain'),
- event.clipboardData.getData('text/html')
+ event.clipboardData.getData('text/html'),
+ shiftHeld
)
) {
event.preventDefault();
@@ -168,10 +222,19 @@ export function createCanvasClipboard(
element.addEventListener('copy', write);
element.addEventListener('cut', write);
element.addEventListener('paste', read);
+ element.addEventListener('keydown', modifiers, true);
+ element.addEventListener('keyup', modifiers, true);
+ element.addEventListener('focusout', resetModifiers);
+ window.addEventListener('blur', resetModifiers);
return () => {
element.removeEventListener('copy', write);
element.removeEventListener('cut', write);
element.removeEventListener('paste', read);
+ element.removeEventListener('keydown', modifiers, true);
+ element.removeEventListener('keyup', modifiers, true);
+ element.removeEventListener('focusout', resetModifiers);
+ window.removeEventListener('blur', resetModifiers);
+ if (viewport === element) viewport = undefined;
};
},
};
diff --git a/apps/web/src/features/block-canvas/components/insert-radial-menu.tsx b/apps/web/src/features/block-canvas/components/insert-radial-menu.tsx
new file mode 100644
index 0000000000..7fa6dc044d
--- /dev/null
+++ b/apps/web/src/features/block-canvas/components/insert-radial-menu.tsx
@@ -0,0 +1,164 @@
+import ImageIcon from '@phosphor/image.svg';
+import LinkIcon from '@phosphor/link.svg';
+import UploadIcon from '@phosphor/upload-simple.svg';
+import {
+ ctrlJKMenuNavigation,
+ wrapIndex,
+} from '@ui/utils/menuKeyboardNavigation';
+import { createSignal, For } from 'solid-js';
+import { radialSliceAtPoint } from '../core/insert';
+
+false && ctrlJKMenuNavigation;
+
+export function CanvasInsertRadialMenu(props: {
+ center: { x: number; y: number };
+ onMedia: () => void;
+ onUpload: () => void;
+ onReference: () => void;
+}) {
+ const choices = [
+ {
+ label: 'Media',
+ icon: ImageIcon,
+ action: props.onMedia,
+ position: 'left-1/2 top-4 -translate-x-1/2',
+ },
+ {
+ label: 'Upload media',
+ icon: UploadIcon,
+ action: props.onUpload,
+ position: 'right-0 top-40',
+ },
+ {
+ label: 'Reference',
+ icon: LinkIcon,
+ action: props.onReference,
+ position: 'left-0 top-40',
+ },
+ ];
+ const [index, setIndex] = createSignal(0);
+ const [active, setActive] = createSignal<number | undefined>(0);
+ const sliceAngle = 360 / choices.length;
+ const ringLength = 2 * Math.PI * 16;
+ const sliceAt = (event: PointerEvent | MouseEvent, element: HTMLElement) => {
+ const rect = element.getBoundingClientRect();
+ return radialSliceAtPoint(
+ event.clientX - rect.left - rect.width / 2,
+ event.clientY - rect.top - rect.height / 2,
+ choices.length
+ );
+ };
+ const buttons: HTMLButtonElement[] = [];
+ let menu!: HTMLDivElement;
+ return (
+ <div
+ class="relative h-dvh w-screen"
+ on:pointermove={(event) => {
+ const next = sliceAt(event, menu);
+ setActive(next);
+ if (next !== undefined) {
+ setIndex(next);
+ buttons[next]?.focus({ preventScroll: true });
+ }
+ }}
+ on:pointerdown={(event) => {
+ if (!(event.target as Element).closest('button'))
+ event.preventDefault();
+ }}
+ onClick={(event) => {
+ if ((event.target as Element).closest('button')) return;
+ const next = active();
+ if (next !== undefined) choices[next].action();
+ }}
+ >
+ <div
+ ref={menu}
+ role="menu"
+ aria-label="Insert"
+ class="absolute h-64 w-80 max-w-[calc(100vw-1rem)]"
+ style={{
+ left: `clamp(8px, ${props.center.x - 160}px, calc(100vw - 328px))`,
+ top: `clamp(8px, ${props.center.y - 128}px, calc(100dvh - 264px))`,
+ }}
+ use:ctrlJKMenuNavigation={{ macOnly: false }}
+ on:keydown={(event) => {
+ if (event.isComposing) return;
+ if (event.key === 'Enter' || event.key === ' ') {
+ event.preventDefault();
+ event.stopPropagation();
+ const selected = active();
+ if (selected !== undefined) choices[selected].action();
+ return;
+ }
+ const delta =
+ event.key === 'ArrowDown' || event.key === 'ArrowRight'
+ ? 1
+ : event.key === 'ArrowUp' || event.key === 'ArrowLeft'
+ ? -1
+ : 0;
+ if (!delta && event.key !== 'Home' && event.key !== 'End') return;
+ event.preventDefault();
+ event.stopPropagation();
+ const next =
+ event.key === 'Home'
+ ? 0
+ : event.key === 'End'
+ ? choices.length - 1
+ : wrapIndex(index(), choices.length, delta);
+ buttons[next]?.focus();
+ }}
+ >
+ <For each={choices}>
+ {(choice, itemIndex) => (
+ <button
+ ref={(el) => {
+ buttons[itemIndex()] = el;
+ }}
+ type="button"
+ role="menuitem"
+ aria-label={choice.label}
+ tabIndex={index() === itemIndex() ? 0 : -1}
+ data-highlighted={active() === itemIndex() ? '' : undefined}
+ onFocus={() => {
+ setIndex(itemIndex());
+ setActive(itemIndex());
+ }}
+ onClick={choice.action}
+ class={`menu-surface absolute flex h-10 w-36 items-center gap-2 rounded-md px-3 text-sm outline-none data-highlighted:bg-[linear-gradient(var(--color-hover),var(--color-hover))] data-highlighted:ring-1 data-highlighted:ring-edge-focus ${choice.position}`}
+ >
+ <choice.icon class="size-4 shrink-0" />
+ {choice.label}
+ </button>
+ )}
+ </For>
+ <div
+ aria-hidden="true"
+ class="pointer-events-none absolute left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2"
+ >
+ <span class="absolute bottom-full left-1/2 mb-2 -translate-x-1/2 text-xs text-ink-muted">
+ Insert
+ </span>
+ <svg class="size-10" viewBox="0 0 40 40" fill="none">
+ <For each={choices}>
+ {(_, slice) => (
+ <circle
+ cx="20"
+ cy="20"
+ r="16"
+ stroke="currentColor"
+ stroke-width="4"
+ stroke-dasharray={`${ringLength / choices.length - 3} ${ringLength - ringLength / choices.length + 3}`}
+ transform={`rotate(${-90 - sliceAngle / 2 + sliceAngle * slice() + (3 / ringLength) * 180} 20 20)`}
+ class={
+ active() === slice() ? 'text-accent' : 'text-edge-muted'
+ }
+ data-active={active() === slice() ? '' : undefined}
+ />
+ )}
+ </For>
+ </svg>
+ </div>
+ </div>
+ </div>
+ );
+}
diff --git a/apps/web/src/features/block-canvas/components/media-content.tsx b/apps/web/src/features/block-canvas/components/media-content.tsx
new file mode 100644
index 0000000000..52663f80b7
--- /dev/null
+++ b/apps/web/src/features/block-canvas/components/media-content.tsx
@@ -0,0 +1,103 @@
+import { createEffect, createSignal, on, onCleanup, Show } from 'solid-js';
+
+export function CanvasMediaSkeleton() {
+ return (
+ <div
+ role="status"
+ aria-label="Loading media"
+ class="skeleton-shimmer size-full bg-skeleton"
+ />
+ );
+}
+
+type MediaContentProps = {
+ url?: string;
+ type: 'image' | 'video';
+ name?: string;
+ unavailable?: boolean;
+ playing: boolean;
+ onStop: () => void;
+};
+
+export function CanvasMediaContent(props: MediaContentProps) {
+ return (
+ <Show when={!props.unavailable} fallback={<MediaUnavailable />}>
+ <Show when={props.url} keyed fallback={<CanvasMediaSkeleton />}>
+ {(url) => <LoadedMedia {...props} url={url} />}
+ </Show>
+ </Show>
+ );
+}
+
+function MediaUnavailable() {
+ return (
+ <div class="grid size-full place-items-center border border-edge-muted bg-panel p-3 text-xs text-ink-muted">
+ Media unavailable
+ </div>
+ );
+}
+
+function LoadedMedia(props: MediaContentProps & { url: string }) {
+ const [loaded, setLoaded] = createSignal(false);
+ const [failed, setFailed] = createSignal(false);
+ const [video, setVideo] = createSignal<HTMLVideoElement>();
+ createEffect(
+ on([video, () => props.playing], ([element, playing]) => {
+ if (!element) return;
+ if (!playing) {
+ element.pause();
+ return;
+ }
+ let cancelled = false;
+ onCleanup(() => {
+ cancelled = true;
+ element.pause();
+ });
+ async function play() {
+ try {
+ await element!.play();
+ } catch {
+ if (!cancelled) props.onStop();
+ }
+ }
+ void play();
+ })
+ );
+ return (
+ <div class="relative size-full" aria-busy={!loaded() && !failed()}>
+ <Show when={!failed()} fallback={<MediaUnavailable />}>
+ <Show when={!loaded()}>
+ <div class="pointer-events-none absolute inset-0">
+ <CanvasMediaSkeleton />
+ </div>
+ </Show>
+ <Show
+ when={props.type === 'image'}
+ fallback={
+ <video
+ ref={setVideo}
+ src={props.url}
+ preload="metadata"
+ playsinline
+ class="size-full object-fill"
+ classList={{ invisible: !loaded() }}
+ onLoadedData={() => setLoaded(true)}
+ onError={() => setFailed(true)}
+ onEnded={props.onStop}
+ />
+ }
+ >
+ <img
+ src={props.url}
+ alt={props.name}
+ draggable={false}
+ class="size-full object-fill"
+ classList={{ invisible: !loaded() }}
+ onLoad={() => setLoaded(true)}
+ onError={() => setFailed(true)}
+ />
+ </Show>
+ </Show>
+ </div>
+ );
+}
diff --git a/apps/web/src/features/block-canvas/components/media-upload-previews.tsx b/apps/web/src/features/block-canvas/components/media-upload-previews.tsx
new file mode 100644
index 0000000000..d8d67fa948
--- /dev/null
+++ b/apps/web/src/features/block-canvas/components/media-upload-previews.tsx
@@ -0,0 +1,39 @@
+import { type Camera, type Point, worldToScreen } from '@macro-inc/graphics';
+import { For } from 'solid-js';
+import type { LocalMediaPreview } from '../core/assets';
+import { CanvasMediaContent } from './media-content';
+
+export function MediaUploadPreviews(props: {
+ previews: readonly (LocalMediaPreview & { point: Point })[];
+ camera: Camera;
+}) {
+ return (
+ <For each={props.previews}>
+ {(preview) => {
+ const point = () => worldToScreen(props.camera, preview.point);
+ const source = preview.media.geometry.source;
+ return (
+ <div
+ data-canvas-upload-preview
+ aria-label={`Uploading ${preview.media.geometry.name ?? 'media'}`}
+ class="pointer-events-none absolute"
+ style={{
+ left: `${point().x}px`,
+ top: `${point().y}px`,
+ width: `${preview.media.geometry.width * props.camera.scale}px`,
+ height: `${preview.media.geometry.height * props.camera.scale}px`,
+ }}
+ >
+ <CanvasMediaContent
+ url={source.type === 'url' ? source.url : undefined}
+ type={preview.media.type}
+ name={preview.media.geometry.name}
+ playing={false}
+ onStop={() => {}}
+ />
+ </div>
+ );
+ }}
+ </For>
+ );
+}
diff --git a/apps/web/src/features/block-canvas/context/reference-source.ts b/apps/web/src/features/block-canvas/context/reference-source.ts
new file mode 100644
index 0000000000..00db61ccf5
--- /dev/null
+++ b/apps/web/src/features/block-canvas/context/reference-source.ts
@@ -0,0 +1,4 @@
+export type CanvasReferenceSource = {
+ create: (targetId: string) => Promise<string>;
+ remove: (mentionId: string) => Promise<void>;
+};
diff --git a/apps/web/src/features/block-canvas/core/assets.ts b/apps/web/src/features/block-canvas/core/assets.ts
index 55ec951fda..d8bb184949 100644
--- a/apps/web/src/features/block-canvas/core/assets.ts
+++ b/apps/web/src/features/block-canvas/core/assets.ts
@@ -4,7 +4,15 @@ export type PreparedMedia = {
type: 'image' | 'video';
geometry: MediaGeometry;
};
+export type LocalMediaPreview = {
+ media: PreparedMedia;
+ dispose: () => void;
+};
export type CanvasAssetSource = {
- upload(file: File): Promise<PreparedMedia>;
+ // The receiver owns the preview URL until it calls dispose, including on failure.
+ upload(
+ file: File,
+ onPreview?: (preview: LocalMediaPreview) => void
+ ): Promise<PreparedMedia>;
media(asset: CanvasAsset): Promise<PreparedMedia>;
};
diff --git a/apps/web/src/features/block-canvas/core/document-format.ts b/apps/web/src/features/block-canvas/core/document-format.ts
index dcc6f3cb3b..3cefb220b8 100644
--- a/apps/web/src/features/block-canvas/core/document-format.ts
+++ b/apps/web/src/features/block-canvas/core/document-format.ts
@@ -1,10 +1,12 @@
import { freezeDocument, type GraphicsDocument } from '@macro-inc/graphics';
+import type { CanvasReferenceTracking } from './references';
import { validCanvasTextDocument } from './text-codec';
export const CANVAS_VERSION = 2;
export type CanvasFile = Readonly<{
version: typeof CANVAS_VERSION;
document: GraphicsDocument;
+ referenceTracking?: CanvasReferenceTracking;
/** Original input is retained for recovery; it is never replayed over edits. */
legacy?: Readonly<{
version: 1;
@@ -46,6 +48,25 @@ export function readCanvasFile(value: unknown): CanvasFile {
!value.legacy.notes.every((note) => typeof note === 'string'))
)
throw new Error('Invalid canvas migration metadata');
+ const tracking = value.referenceTracking;
+ if (
+ tracking !== undefined &&
+ (!isRecord(tracking) ||
+ typeof tracking.sourceId !== 'string' ||
+ !tracking.sourceId ||
+ !Array.isArray(tracking.mentions) ||
+ !tracking.mentions.every(
+ (mention) =>
+ isRecord(mention) &&
+ typeof mention.targetId === 'string' &&
+ !!mention.targetId &&
+ typeof mention.mentionId === 'string' &&
+ !!mention.mentionId
+ ) ||
+ !Array.isArray(tracking.pendingRemoval) ||
+ !tracking.pendingRemoval.every((id) => typeof id === 'string' && !!id))
+ )
+ throw new Error('Invalid canvas reference tracking metadata');
// Retain same-version extension fields rather than stripping them on save.
return { ...value, version: CANVAS_VERSION, document } as CanvasFile;
}
diff --git a/apps/web/src/features/block-canvas/core/insert.test.ts b/apps/web/src/features/block-canvas/core/insert.test.ts
new file mode 100644
index 0000000000..10025b9ee1
--- /dev/null
+++ b/apps/web/src/features/block-canvas/core/insert.test.ts
@@ -0,0 +1,21 @@
+import { expect, it } from 'vitest';
+import { canInsertAsset, radialSliceAtPoint } from './insert';
+
+it('limits media to images/videos and allows document references', () => {
+ expect(canInsertAsset('media', 'image')).toBe(true);
+ expect(canInsertAsset('media', 'video')).toBe(true);
+ expect(canInsertAsset('media', 'pdf')).toBe(false);
+ expect(canInsertAsset('reference', 'pdf')).toBe(true);
+});
+
+it('divides a full turn into equal slices and keeps the center neutral', () => {
+ expect(radialSliceAtPoint(0, -100, 3)).toBe(0);
+ expect(radialSliceAtPoint(100, 50, 3)).toBe(1);
+ expect(radialSliceAtPoint(-100, 50, 3)).toBe(2);
+ expect(radialSliceAtPoint(-1, 100, 3)).toBe(2);
+ expect(radialSliceAtPoint(1, 100, 3)).toBe(1);
+ expect(radialSliceAtPoint(10, 10, 3)).toBeUndefined();
+ expect(radialSliceAtPoint(100, 0, 4)).toBe(1);
+ expect(radialSliceAtPoint(0, 100, 4)).toBe(2);
+ expect(radialSliceAtPoint(-100, 0, 4)).toBe(3);
+});
diff --git a/apps/web/src/features/block-canvas/core/insert.ts b/apps/web/src/features/block-canvas/core/insert.ts
new file mode 100644
index 0000000000..68b94fa921
--- /dev/null
+++ b/apps/web/src/features/block-canvas/core/insert.ts
@@ -0,0 +1,14 @@
+export type CanvasInsertMode = 'media' | 'reference';
+
+export function canInsertAsset(mode: CanvasInsertMode, blockType: string) {
+ return mode === 'reference' || blockType === 'image' || blockType === 'video';
+}
+
+/** Clockwise equal slices, with the first option centered above the origin. */
+export function radialSliceAtPoint(x: number, y: number, count: number) {
+ if (count < 1 || Math.hypot(x, y) < 24) return undefined;
+ const turn = Math.PI * 2;
+ const slice = turn / count;
+ const angle = (Math.atan2(y, x) + Math.PI / 2 + slice / 2 + turn) % turn;
+ return Math.floor(angle / slice);
+}
diff --git a/apps/web/src/features/block-canvas/core/references.ts b/apps/web/src/features/block-canvas/core/references.ts
new file mode 100644
index 0000000000..248d474f7e
--- /dev/null
+++ b/apps/web/src/features/block-canvas/core/references.ts
@@ -0,0 +1,22 @@
+import type { GraphicsDocument } from '@macro-inc/graphics';
+
+/** Tracking belongs to the canvas file, not individual copyable shapes. */
+export type CanvasReferenceTracking = {
+ sourceId: string;
+ mentions: { targetId: string; mentionId: string }[];
+ /** Deletions run after saving and remain durable until a later save prunes them. */
+ pendingRemoval: string[];
+};
+
+export function canvasReferenceTargets(
+ document: GraphicsDocument
+): Set<string> {
+ return new Set(
+ Object.values(document.items).flatMap((item) =>
+ item.type === 'document' &&
+ (!item.geometry.entityType || item.geometry.entityType === 'document')
+ ? [item.geometry.documentId]
+ : []
+ )
+ );
+}
diff --git a/apps/web/src/features/block-canvas/hotkeys.ts b/apps/web/src/features/block-canvas/hotkeys.ts
index 048f25df62..689410867f 100644
--- a/apps/web/src/features/block-canvas/hotkeys.ts
+++ b/apps/web/src/features/block-canvas/hotkeys.ts
@@ -10,7 +10,8 @@ export function registerCanvasNextHotkeys(
scopeId: string,
state: CanvasState,
clipboard: CanvasClipboard,
- canEdit: () => boolean = () => true
+ canEdit: () => boolean = () => true,
+ onInsert?: () => void
) {
const group = createHotkeyGroup(),
editor = state.editor;
@@ -53,6 +54,7 @@ export function registerCanvasNextHotkeys(
register('l', 'Line tool', () => state.chooseTool('line'));
register('e', 'Eraser tool', () => state.chooseTool('eraser'));
register('t', 'Text tool', () => state.chooseTool('text'));
+ if (onInsert) register('i', 'Insert', onInsert);
register('enter', 'Edit selected text', () => {
const id = editor.getSession().selectedId;
if (id) state.text.edit(id);
@@ -108,6 +110,15 @@ export function registerCanvasNextHotkeys(
true
);
register('cmd+z', 'Undo', editor.undo, TOKENS.canvas.undo);
+ register(
+ 'shift+cmd+v',
+ 'Paste in place',
+ () => {
+ void clipboard.paste(true);
+ },
+ undefined,
+ true
+ );
register(['shift+cmd+z', 'cmd+y'], 'Redo', editor.redo, TOKENS.canvas.redo);
register(
['delete', 'backspace'],
diff --git a/apps/web/src/features/block-canvas/primitives/create-asset-state.test.ts b/apps/web/src/features/block-canvas/primitives/create-asset-state.test.ts
index f0bf3ee67d..11bc805f76 100644
--- a/apps/web/src/features/block-canvas/primitives/create-asset-state.test.ts
+++ b/apps/web/src/features/block-canvas/primitives/create-asset-state.test.ts
@@ -35,6 +35,103 @@ function setup(source: CanvasAssetSource) {
return { editor, assets: createAssetState(canvas, source), canvas };
});
}
+function deferredUpload() {
+ let resolve!: (value: PreparedMedia) => void;
+ let reject!: (error: Error) => void;
+ const promise = new Promise<PreparedMedia>((res, rej) => {
+ resolve = res;
+ reject = rej;
+ });
+ const dispose = vi.fn();
+ const source: CanvasAssetSource = {
+ upload: (_file, onPreview) => {
+ onPreview?.({
+ media: {
+ ...media,
+ geometry: {
+ ...media.geometry,
+ source: { type: 'url', url: 'blob:local' },
+ },
+ },
+ dispose,
+ });
+ return promise;
+ },
+ media: async () => media,
+ };
+ return { resolve, reject, dispose, source };
+}
+
+it('shows local media during upload without putting blob URLs in the scene or history', async () => {
+ const upload = deferredUpload();
+ const { assets, editor } = setup(upload.source);
+ const pending = assets.files([new File(['a'], 'a.png')], { x: 300, y: 200 });
+ expect(assets.previews()).toMatchObject([
+ {
+ point: { x: 200, y: 150 },
+ media: { geometry: { source: { url: 'blob:local' } } },
+ },
+ ]);
+ expect(drawableIds(editor.document)).toHaveLength(0);
+ expect(editor.getSession().canUndo).toBe(false);
+ expect(upload.dispose).not.toHaveBeenCalled();
+ upload.resolve(media);
+ await pending;
+ expect(assets.previews()).toHaveLength(0);
+ expect(upload.dispose).toHaveBeenCalledOnce();
+ expect(JSON.stringify(editor.document)).not.toContain('blob:');
+ editor.undo();
+ expect(drawableIds(editor.document)).toHaveLength(0);
+ editor.redo();
+ expect(drawableIds(editor.document)).toHaveLength(1);
+ expect(JSON.stringify(editor.document)).not.toContain('blob:');
+});
+
+it('removes failed previews and releases their URLs', async () => {
+ const upload = deferredUpload();
+ const { assets, editor, canvas } = setup(upload.source);
+ const pending = assets.files([new File(['a'], 'a.png')], { x: 0, y: 0 });
+ upload.reject(new Error('Upload failed'));
+ await pending;
+ expect(assets.previews()).toHaveLength(0);
+ expect(upload.dispose).toHaveBeenCalledOnce();
+ expect(drawableIds(editor.document)).toHaveLength(0);
+ expect(canvas.notice()).toContain('1 could not be loaded');
+});
+
+it('releases previews on reset and ignores late upload completion', async () => {
+ const upload = deferredUpload();
+ const { assets, editor } = setup(upload.source);
+ const pending = assets.files([new File(['a'], 'a.png')], { x: 0, y: 0 });
+ assets.cancelPending();
+ expect(assets.previews()).toHaveLength(0);
+ expect(upload.dispose).toHaveBeenCalledOnce();
+ upload.resolve(media);
+ await pending;
+ expect(drawableIds(editor.document)).toHaveLength(0);
+ expect(upload.dispose).toHaveBeenCalledOnce();
+});
+
+it('keeps concurrent upload previews until their own batches finish', async () => {
+ const first = deferredUpload();
+ const second = deferredUpload();
+ const { assets } = setup({
+ upload: (file, onPreview) =>
+ (file.name === 'a.png' ? first : second).source.upload(file, onPreview),
+ media: async () => media,
+ });
+ const one = assets.files([new File(['a'], 'a.png')], { x: 0, y: 0 });
+ const two = assets.files([new File(['b'], 'b.png')], { x: 100, y: 100 });
+ expect(assets.previews()).toHaveLength(2);
+ first.resolve(media);
+ await one;
+ expect(assets.previews()).toHaveLength(1);
+ expect(second.dispose).not.toHaveBeenCalled();
+ second.resolve(media);
+ await two;
+ expect(assets.previews()).toHaveLength(0);
+ expect(second.dispose).toHaveBeenCalledOnce();
+});
it('batches file inserts as one undo entry and preserves stable references on redo', async () => {
const { editor, assets } = setup({
upload: vi.fn(async () => media),
diff --git a/apps/web/src/features/block-canvas/primitives/create-asset-state.ts b/apps/web/src/features/block-canvas/primitives/create-asset-state.ts
index f16abb3e44..d66983eac1 100644
--- a/apps/web/src/features/block-canvas/primitives/create-asset-state.ts
+++ b/apps/web/src/features/block-canvas/primitives/create-asset-state.ts
@@ -3,6 +3,7 @@ import { createSignal, onCleanup } from 'solid-js';
import type {
CanvasAsset,
CanvasAssetSource,
+ LocalMediaPreview,
PreparedMedia,
} from '../core/assets';
import { canEmbedDocument } from '../core/document-display';
@@ -14,11 +15,19 @@ export function createAssetState(
) {
const [busy, setBusy] = createSignal(0);
const [playing, setPlaying] = createSignal<string>();
+ const [previews, setPreviews] = createSignal<
+ readonly (LocalMediaPreview & { point: Point })[]
+ >([]);
+ const clearPreviews = () => {
+ for (const preview of previews()) preview.dispose();
+ setPreviews([]);
+ };
let generation = 0,
disposed = false;
onCleanup(() => {
disposed = true;
generation++;
+ clearPreviews();
});
const appearance = {
fill: 'transparent',
@@ -26,11 +35,14 @@ export function createAssetState(
strokeWidth: 0,
opacity: 1,
};
- const insert = (items: readonly PreparedMedia[], point: Point) => {
+ const insert = (
+ items: readonly { media: PreparedMedia; index: number }[],
+ point: Point
+ ) => {
state.chooseTool('select');
state.editor.execute(
insertShapesCommand,
- items.map((media, index) => ({
+ items.map(({ media, index }) => ({
item: { id: crypto.randomUUID(), ...media, appearance },
point: {
x: point.x - media.geometry.width / 2 + index * 24,
@@ -39,15 +51,39 @@ export function createAssetState(
}))
);
};
- async function load(tasks: (() => Promise<PreparedMedia>)[], point: Point) {
+ async function load(
+ tasks: ((
+ onPreview: (preview: LocalMediaPreview) => void
+ ) => Promise<PreparedMedia>)[],
+ point: Point
+ ) {
const started = generation;
+ const localPreviews = new Set<LocalMediaPreview>();
setBusy((value) => value + 1);
state.setNotice('Loading media…');
try {
- const results = await Promise.allSettled(tasks.map((task) => task()));
+ const results = await Promise.allSettled(
+ tasks.map((task, index) =>
+ task((preview) => {
+ if (disposed || started !== generation) {
+ preview.dispose();
+ return;
+ }
+ const placed = {
+ ...preview,
+ point: {
+ x: point.x - preview.media.geometry.width / 2 + index * 24,
+ y: point.y - preview.media.geometry.height / 2 + index * 24,
+ },
+ };
+ localPreviews.add(placed);
+ setPreviews((current) => [...current, placed]);
+ })
+ )
+ );
if (disposed || started !== generation) return;
- const media = results.flatMap((result) =>
- result.status === 'fulfilled' ? [result.value] : []
+ const media = results.flatMap((result, index) =>
+ result.status === 'fulfilled' ? [{ media: result.value, index }] : []
);
if (media.length) insert(media, point);
const failed = results.filter(
@@ -59,22 +95,31 @@ export function createAssetState(
: `Inserted ${media.length} media item${media.length === 1 ? '' : 's'}`
);
} finally {
+ setPreviews((current) =>
+ current.filter((preview) => {
+ if (!localPreviews.has(preview)) return true;
+ preview.dispose();
+ return false;
+ })
+ );
if (!disposed) setBusy((value) => value - 1);
}
}
return {
busy,
+ previews,
playing,
togglePlayback: (id: string) =>
setPlaying((current) => (current === id ? undefined : id)),
stopPlayback: () => setPlaying(undefined),
cancelPending: () => {
generation++;
+ clearPreviews();
setPlaying(undefined);
},
files: (files: readonly File[], point: Point) =>
load(
- files.map((file) => () => source.upload(file)),
+ files.map((file) => (onPreview) => source.upload(file, onPreview)),
point
),
media: (asset: CanvasAsset, point: Point) =>
diff --git a/apps/web/src/features/block-canvas/primitives/create-insert-state.test.ts b/apps/web/src/features/block-canvas/primitives/create-insert-state.test.ts
new file mode 100644
index 0000000000..c48d53fd91
--- /dev/null
+++ b/apps/web/src/features/block-canvas/primitives/create-insert-state.test.ts
@@ -0,0 +1,85 @@
+import { createRoot } from 'solid-js';
+import { describe, expect, it } from 'vitest';
+import { createCanvasInsertState } from './create-insert-state';
+
+function viewport() {
+ const element = document.createElement('div');
+ element.getBoundingClientRect = () => new DOMRect(100, 50, 800, 600);
+ return element;
+}
+function pointer(element: HTMLElement, x: number, y: number) {
+ element.dispatchEvent(
+ new MouseEvent('pointermove', { clientX: x, clientY: y })
+ );
+}
+
+describe('canvas insertion location', () => {
+ it('captures the pointer in world coordinates and keeps it fixed while the menu is open', () =>
+ createRoot((dispose) => {
+ let camera = { x: 20, y: -10, scale: 2 };
+ const state = createCanvasInsertState(() => camera);
+ const element = viewport();
+ const detach = state.attach(element);
+ pointer(element, 320, 230);
+ state.open();
+ expect(state.location()).toEqual({
+ screen: { x: 320, y: 230 },
+ world: { x: 100, y: 95 },
+ });
+ pointer(element, 700, 500);
+ camera = { x: 0, y: 0, scale: 1 };
+ state.open();
+ expect(state.location()?.world).toEqual({ x: 100, y: 95 });
+ state.close();
+ state.open();
+ expect(state.location()?.world).toEqual({ x: 600, y: 450 });
+ detach();
+ dispose();
+ }));
+
+ it('falls back to the viewport center before a pointer arrives and after it leaves', () =>
+ createRoot((dispose) => {
+ const state = createCanvasInsertState(() => ({ x: 0, y: 0, scale: 1 }));
+ const element = viewport();
+ const detach = state.attach(element);
+ state.open();
+ expect(state.location()).toEqual({
+ screen: { x: 500, y: 350 },
+ world: { x: 400, y: 300 },
+ });
+ state.close();
+ pointer(element, 250, 250);
+ element.dispatchEvent(new Event('pointerleave'));
+ state.open();
+ expect(state.location()?.screen).toEqual({ x: 500, y: 350 });
+ state.close();
+ detach();
+ state.open();
+ expect(state.location()).toBeUndefined();
+ dispose();
+ }));
+ it('anchors the toolbar dropdown to its button while inserting at the canvas center', () =>
+ createRoot((dispose) => {
+ const state = createCanvasInsertState(() => ({
+ x: 20,
+ y: -10,
+ scale: 2,
+ }));
+ const element = viewport();
+ const detach = state.attach(element);
+ pointer(element, 250, 200);
+ state.openFromToolbar({ x: 700, y: 620 });
+ expect(state.location()).toEqual({
+ screen: { x: 700, y: 620 },
+ world: { x: 190, y: 155 },
+ presentation: 'dropdown',
+ });
+ state.open();
+ expect(state.location()?.presentation).toBe('dropdown');
+ state.close();
+ state.open();
+ expect(state.location()?.presentation).toBeUndefined();
+ detach();
+ dispose();
+ }));
+});
diff --git a/apps/web/src/features/block-canvas/primitives/create-insert-state.ts b/apps/web/src/features/block-canvas/primitives/create-insert-state.ts
new file mode 100644
index 0000000000..5e5ea73fb9
--- /dev/null
+++ b/apps/web/src/features/block-canvas/primitives/create-insert-state.ts
@@ -0,0 +1,66 @@
+import { type Camera, type Point, screenToWorld } from '@macro-inc/graphics';
+import { createSignal } from 'solid-js';
+
+export type CanvasInsertLocation = {
+ screen: Point;
+ world: Point;
+ presentation?: 'dropdown';
+};
+
+export function createCanvasInsertState(camera: () => Camera) {
+ const [location, setLocation] = createSignal<CanvasInsertLocation>();
+ let viewport: HTMLElement | undefined;
+ let pointer: Point | undefined;
+ return {
+ location,
+ close: () => setLocation(undefined),
+ open() {
+ if (!viewport || location()) return;
+ const rect = viewport.getBoundingClientRect();
+ const screen = pointer ?? {
+ x: rect.left + rect.width / 2,
+ y: rect.top + rect.height / 2,
+ };
+ setLocation({
+ screen,
+ world: screenToWorld(camera(), {
+ x: screen.x - rect.left,
+ y: screen.y - rect.top,
+ }),
+ });
+ },
+ openFromToolbar(screen: Point) {
+ if (!viewport || location()) return;
+ const rect = viewport.getBoundingClientRect();
+ setLocation({
+ screen,
+ world: screenToWorld(camera(), {
+ x: rect.width / 2,
+ y: rect.height / 2,
+ }),
+ presentation: 'dropdown',
+ });
+ },
+ attach(element: HTMLElement) {
+ viewport = element;
+ const track = (event: PointerEvent) => {
+ pointer = { x: event.clientX, y: event.clientY };
+ };
+ const leave = () => {
+ pointer = undefined;
+ };
+ element.addEventListener('pointermove', track);
+ element.addEventListener('pointerdown', track);
+ element.addEventListener('pointerleave', leave);
+ return () => {
+ element.removeEventListener('pointermove', track);
+ element.removeEventListener('pointerdown', track);
+ element.removeEventListener('pointerleave', leave);
+ viewport = undefined;
+ pointer = undefined;
+ };
+ },
+ };
+}
+
+export type CanvasInsertState = ReturnType<typeof createCanvasInsertState>;
diff --git a/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.test.ts b/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.test.ts
new file mode 100644
index 0000000000..8ac68ce7e4
--- /dev/null
+++ b/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.test.ts
@@ -0,0 +1,131 @@
+import { createScene, translation } from '@macro-inc/graphics';
+import { expect, it, vi } from 'vitest';
+import type { CanvasFile } from '../core/document-format';
+import { readCanvasFile } from '../core/document-format';
+import { createTrackedCanvasDocumentSource } from './create-tracked-document-source';
+
+function canvas(...targets: string[]): CanvasFile {
+ return {
+ version: 2,
+ document: createScene(
+ targets.map((target, index) => ({
+ id: `shape-${index}`,
+ type: 'document' as const,
+ placement: { parentId: 'scene-root', sortKey: `a${index}` },
+ transform: translation(0, 0),
+ appearance: { fill: 'none', stroke: 'none' },
+ geometry: {
+ documentId: target,
+ name: target,
+ fileType: 'md',
+ width: 340,
+ height: 136,
+ },
+ }))
+ ),
+ };
+}
+function setup(initial = canvas()) {
+ const create = vi.fn(
+ async (target: string) => `${target}-${create.mock.calls.length}`
+ );
+ const remove = vi.fn(async (_id: string) => {});
+ const save = vi.fn(async (_file: CanvasFile) => new Blob());
+ const canEdit = vi.fn(() => true);
+ const source = createTrackedCanvasDocumentSource(
+ 'source',
+ initial,
+ { canEdit, save },
+ { create, remove }
+ );
+ return { source, create, remove, save, canEdit };
+}
+
+it('tracks one mention per target and preserves IDs across saves and reopening', async () => {
+ const s = setup();
+ await s.source.save(canvas('a', 'a', 'b'));
+ expect(s.create.mock.calls).toEqual([['a'], ['b']]);
+ const saved = readCanvasFile(s.save.mock.calls[0]![0]);
+ expect(saved.referenceTracking?.mentions).toHaveLength(2);
+ await s.source.save(canvas('a', 'b'));
+ expect(s.remove).not.toHaveBeenCalled();
+ expect(s.create).toHaveBeenCalledTimes(2);
+ const reopened = setup(saved);
+ await reopened.source.save(canvas('a', 'b'));
+ expect(reopened.create).not.toHaveBeenCalled();
+});
+
+it('untracks only after the last card is saved as removed and registers undo/redo', async () => {
+ const s = setup();
+ await s.source.save(canvas('a', 'a'));
+ await s.source.save(canvas('a'));
+ expect(s.remove).not.toHaveBeenCalled();
+ await s.source.save(canvas());
+ expect(
+ s.save.mock.calls.at(-1)?.[0].referenceTracking?.pendingRemoval
+ ).toEqual(['a-1']);
+ expect(s.remove).toHaveBeenCalledWith('a-1');
+ expect(s.save.mock.invocationCallOrder.at(-1)!).toBeLessThan(
+ s.remove.mock.invocationCallOrder[0]!
+ );
+ await s.source.save(canvas('a'));
+ expect(s.create).toHaveBeenCalledTimes(2);
+ await s.source.save(canvas());
+ expect(s.remove).toHaveBeenLastCalledWith('a-2');
+});
+
+it('keeps IDs across failed saves and defers untracking until a successful retry', async () => {
+ const s = setup();
+ s.save.mockRejectedValueOnce(new Error('offline'));
+ await expect(s.source.save(canvas('a'))).rejects.toThrow('offline');
+ await s.source.save(canvas('a'));
+ expect(s.create).toHaveBeenCalledOnce();
+ s.save.mockRejectedValueOnce(new Error('offline'));
+ await expect(s.source.save(canvas())).rejects.toThrow('offline');
+ expect(s.remove).not.toHaveBeenCalled();
+ await s.source.save(canvas());
+ expect(s.remove).toHaveBeenCalledWith('a-1');
+});
+
+it('persists pending removals so a reopened file can retry failed cleanup', async () => {
+ const s = setup();
+ await s.source.save(canvas('a'));
+ s.remove.mockRejectedValueOnce(new Error('offline'));
+ await expect(s.source.save(canvas())).rejects.toThrow('offline');
+ const reopened = setup(s.save.mock.calls.at(-1)![0]);
+ await reopened.source.save(canvas());
+ expect(reopened.remove).toHaveBeenCalledWith('a-1');
+ await reopened.source.save(canvas());
+ expect(
+ reopened.save.mock.calls.at(-1)?.[0].referenceTracking?.pendingRemoval
+ ).toEqual([]);
+});
+
+it('does not use another canvas’s tracking IDs or mutate read-only documents', async () => {
+ const initial = canvas('a');
+ const s = setup({
+ ...initial,
+ referenceTracking: {
+ sourceId: 'other',
+ mentions: [{ targetId: 'a', mentionId: 'foreign' }],
+ pendingRemoval: ['foreign-old'],
+ },
+ });
+ await s.source.save(initial);
+ expect(s.create).toHaveBeenCalledWith('a');
+ expect(s.remove).not.toHaveBeenCalled();
+ s.canEdit.mockReturnValue(false);
+ await expect(s.source.save(canvas())).rejects.toThrow('read-only');
+ expect(s.remove).not.toHaveBeenCalled();
+ expect(s.save).toHaveBeenCalledOnce();
+});
+
+it('retries a failed registration without creating duplicates for earlier targets', async () => {
+ const s = setup();
+ s.create
+ .mockResolvedValueOnce('mention-a')
+ .mockRejectedValueOnce(new Error('offline'));
+ await expect(s.source.save(canvas('a', 'b'))).rejects.toThrow('offline');
+ await s.source.save(canvas('a', 'b'));
+ expect(s.create.mock.calls).toEqual([['a'], ['b'], ['b']]);
+});
diff --git a/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.ts b/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.ts
new file mode 100644
index 0000000000..f70c0ef771
--- /dev/null
+++ b/apps/web/src/features/block-canvas/primitives/create-tracked-document-source.ts
@@ -0,0 +1,62 @@
+import type { CanvasDocumentSource } from '../context/document-source';
+import type { CanvasReferenceSource } from '../context/reference-source';
+import type { CanvasFile } from '../core/document-format';
+import { canvasReferenceTargets } from '../core/references';
+
+/** Called by serialized document persistence, so tracking follows saved snapshots. */
+export function createTrackedCanvasDocumentSource(
+ sourceId: string,
+ initial: CanvasFile,
+ documentSource: CanvasDocumentSource,
+ references: CanvasReferenceSource
+): CanvasDocumentSource {
+ // A file copied to a different canvas must never remove the original's mentions.
+ const stored =
+ initial.referenceTracking?.sourceId === sourceId
+ ? initial.referenceTracking
+ : undefined;
+ const active = new Map(
+ stored?.mentions.map(({ targetId, mentionId }) => [targetId, mentionId])
+ );
+ const retiring = new Set(stored?.pendingRemoval);
+ const requireEdit = () => {
+ if (!documentSource.canEdit()) throw new Error('This canvas is read-only');
+ };
+ return {
+ canEdit: documentSource.canEdit,
+ async save(canvas) {
+ requireEdit();
+ const targets = canvasReferenceTargets(canvas.document);
+ for (const [target, mention] of active) {
+ if (targets.has(target)) continue;
+ retiring.add(mention);
+ active.delete(target);
+ }
+ for (const target of targets) {
+ if (active.has(target)) continue;
+ requireEdit();
+ active.set(target, await references.create(target));
+ }
+ requireEdit();
+ const file = await documentSource.save({
+ ...canvas,
+ referenceTracking: {
+ sourceId,
+ mentions: Array.from(active, ([targetId, mentionId]) => ({
+ targetId,
+ mentionId,
+ })),
+ pendingRemoval: [...retiring],
+ },
+ });
+ // Never untrack a card until its deletion is durable. On failure these IDs
+ // remain both in memory and in the saved file for an idempotent retry.
+ for (const mention of retiring) {
+ requireEdit();
+ await references.remove(mention);
+ retiring.delete(mention);
+ }
+ return file;
+ },
+ };
+}
diff --git a/apps/web/src/features/block-canvas/queries/assets.ts b/apps/web/src/features/block-canvas/queries/assets.ts
index ff9e8b1670..6d391b07e0 100644
--- a/apps/web/src/features/block-canvas/queries/assets.ts
+++ b/apps/web/src/features/block-canvas/queries/assets.ts
@@ -49,7 +49,7 @@ async function dimensions(url: string, type: 'image' | 'video') {
});
}
export const canvasAssetSource: CanvasAssetSource = {
- async upload(file) {
+ async upload(file, onPreview) {
const type = fileTypeToBlockName(file.name.split('.').pop());
const kind =
file.type.startsWith('video/') || type === 'video'
@@ -58,6 +58,26 @@ export const canvasAssetSource: CanvasAssetSource = {
? 'image'
: undefined;
if (!kind) throw new Error('Choose an image or video');
+ if (onPreview) {
+ const url = URL.createObjectURL(file);
+ try {
+ const size = await dimensions(url, kind);
+ onPreview({
+ media: {
+ type: kind,
+ geometry: {
+ ...size,
+ source: { type: 'url', url },
+ name: file.name,
+ },
+ },
+ dispose: () => URL.revokeObjectURL(url),
+ });
+ } catch {
+ // Formats such as HEIC may only be decodable after upload conversion.
+ URL.revokeObjectURL(url);
+ }
+ }
// The shared uploader handles validation and HEIC conversion.
const result = await uploadFile(file, 'static', {
hideProgressIndicator: true,
diff --git a/apps/web/src/features/block-canvas/queries/document.test.ts b/apps/web/src/features/block-canvas/queries/document.test.ts
index 9340bb3a3f..581e4d20b1 100644
--- a/apps/web/src/features/block-canvas/queries/document.test.ts
+++ b/apps/web/src/features/block-canvas/queries/document.test.ts
@@ -11,7 +11,10 @@ afterEach(() => vi.clearAllMocks());
it('surfaces rejected JSON saves so the session can retry', async () => {
const editor = createGraphicsEditor();
- const source = canvasDocumentSource('canvas-id', () => true);
+ const source = canvasDocumentSource('canvas-id', () => true, {
+ version: 2,
+ document: editor.document,
+ });
simpleSave
.mockResolvedValueOnce(err('offline'))
.mockResolvedValueOnce(ok({}));
@@ -28,7 +31,10 @@ it('surfaces rejected JSON saves so the session can retry', async () => {
it('never submits a read-only document', async () => {
const editor = createGraphicsEditor();
await expect(
- canvasDocumentSource('viewer', () => false).save({
+ canvasDocumentSource('viewer', () => false, {
+ version: 2,
+ document: editor.document,
+ }).save({
version: 2,
document: editor.document,
})
diff --git a/apps/web/src/features/block-canvas/queries/document.ts b/apps/web/src/features/block-canvas/queries/document.ts
index 1d8fb2ab1a..382dce086d 100644
--- a/apps/web/src/features/block-canvas/queries/document.ts
+++ b/apps/web/src/features/block-canvas/queries/document.ts
@@ -1,12 +1,17 @@
+import { ENABLE_MENTION_TRACKING } from '@core/constant/featureFlags';
import type { CanvasDocumentSource } from '../context/document-source';
+import type { CanvasFile } from '../core/document-format';
import { readCanvasFile } from '../core/document-format';
+import { createTrackedCanvasDocumentSource } from '../primitives/create-tracked-document-source';
import { saveCanvasDocument } from './canvas-document';
+import { canvasReferenceSource } from './references';
export function canvasDocumentSource(
documentId: string,
- canEdit: () => boolean
+ canEdit: () => boolean,
+ initial: CanvasFile
): CanvasDocumentSource {
- return {
+ const source: CanvasDocumentSource = {
canEdit,
async save(canvas) {
if (!canEdit()) throw new Error('This canvas is read-only');
@@ -18,4 +23,12 @@ export function canvasDocumentSource(
return file;
},
};
+ return ENABLE_MENTION_TRACKING
+ ? createTrackedCanvasDocumentSource(
+ documentId,
+ initial,
+ source,
+ canvasReferenceSource(documentId)
+ )
+ : source;
}
diff --git a/apps/web/src/features/block-canvas/queries/references.test.ts b/apps/web/src/features/block-canvas/queries/references.test.ts
new file mode 100644
index 0000000000..4de92b06aa
--- /dev/null
+++ b/apps/web/src/features/block-canvas/queries/references.test.ts
@@ -0,0 +1,83 @@
+import { err, ok } from 'neverthrow';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { canvasReferenceSource } from './references';
+
+const mocks = vi.hoisted(() => ({
+ token: vi.fn(),
+ create: vi.fn(),
+ remove: vi.fn(),
+ invalidate: vi.fn(),
+}));
+vi.mock('@core/signal/token', () => ({ getPermissionToken: mocks.token }));
+vi.mock('@queries/client', () => ({
+ queryClient: { invalidateQueries: mocks.invalidate },
+}));
+vi.mock('@service-storage/client', () => ({
+ storageServiceClient: {
+ createEntityMention: mocks.create,
+ deleteEntityMention: mocks.remove,
+ },
+}));
+beforeEach(() => {
+ vi.resetAllMocks();
+ mocks.token.mockResolvedValue('permission');
+ mocks.create.mockResolvedValue(ok({ id: 'mention' }));
+ mocks.remove.mockResolvedValue(ok({}));
+});
+
+it('registers a document backlink with source authorization and refreshes references', async () => {
+ await expect(canvasReferenceSource('canvas').create('target')).resolves.toBe(
+ 'mention'
+ );
+ expect(mocks.token).toHaveBeenCalledWith('document', 'canvas');
+ expect(mocks.create).toHaveBeenCalledWith(
+ {
+ source_entity_type: 'document',
+ source_entity_id: 'canvas',
+ entity_type: 'document',
+ entity_id: 'target',
+ },
+ 'permission'
+ );
+ expect(mocks.invalidate).toHaveBeenCalledOnce();
+});
+
+it('retries deletion safely after a previously completed removal', async () => {
+ mocks.remove.mockResolvedValueOnce(
+ err([{ code: 'NOT_FOUND', message: 'Gone' }])
+ );
+ await expect(
+ canvasReferenceSource('canvas').remove('mention')
+ ).resolves.toBeUndefined();
+ expect(mocks.remove).toHaveBeenCalledWith(
+ { mention_id: 'mention' },
+ 'permission'
+ );
+ expect(mocks.invalidate).toHaveBeenCalledOnce();
+ mocks.remove.mockResolvedValueOnce(
+ err([{ code: 'UNKNOWN', message: 'Offline' }])
+ );
+ await expect(
+ canvasReferenceSource('canvas').remove('mention')
+ ).rejects.toThrow('Offline');
+ expect(mocks.invalidate).toHaveBeenCalledOnce();
+});
+
+it('surfaces registration and authorization failures for persistence retry', async () => {
+ mocks.create.mockResolvedValueOnce(
+ err([{ code: 'UNKNOWN', message: 'Offline' }])
+ );
+ await expect(
+ canvasReferenceSource('canvas').create('target')
+ ).rejects.toThrow('Offline');
+ expect(mocks.invalidate).not.toHaveBeenCalled();
+ mocks.token.mockResolvedValue(undefined);
+ await expect(
+ canvasReferenceSource('canvas').create('target')
+ ).rejects.toThrow('authorize');
+ await expect(
+ canvasReferenceSource('canvas').remove('mention')
+ ).rejects.toThrow('authorize');
+ expect(mocks.create).toHaveBeenCalledOnce();
+ expect(mocks.remove).not.toHaveBeenCalled();
+});
diff --git a/apps/web/src/features/block-canvas/queries/references.ts b/apps/web/src/features/block-canvas/queries/references.ts
new file mode 100644
index 0000000000..c7ba073671
--- /dev/null
+++ b/apps/web/src/features/block-canvas/queries/references.ts
@@ -0,0 +1,53 @@
+import { getPermissionToken } from '@core/signal/token';
+import { throwOnErr } from '@core/util/result';
+import { queryClient } from '@queries/client';
+import { attachmentReferencesKeys } from '@queries/storage/keys';
+import { storageServiceClient } from '@service-storage/client';
+import type { CanvasReferenceSource } from '../context/reference-source';
+
+/** Same entity-mention API and reference query invalidation used by mentions. */
+export function canvasReferenceSource(sourceId: string): CanvasReferenceSource {
+ async function token() {
+ const token = await getPermissionToken('document', sourceId);
+ if (!token)
+ throw new Error('Could not authorize canvas reference tracking');
+ return token;
+ }
+ return {
+ async create(targetId) {
+ const permission = await token();
+ const mention = await throwOnErr(() =>
+ storageServiceClient.createEntityMention(
+ {
+ source_entity_type: 'document',
+ source_entity_id: sourceId,
+ entity_type: 'document',
+ entity_id: targetId,
+ },
+ permission
+ )
+ );
+ void queryClient.invalidateQueries({
+ queryKey: attachmentReferencesKeys.list('document', targetId).queryKey,
+ });
+ return mention.id;
+ },
+ async remove(mentionId) {
+ const response = await storageServiceClient.deleteEntityMention(
+ { mention_id: mentionId },
+ await token()
+ );
+ // The file can retain a completed deletion until its next content save.
+ if (
+ !(
+ response.isErr() &&
+ response.error.every((error) => error.code === 'NOT_FOUND')
+ )
+ )
+ await throwOnErr(async () => response);
+ void queryClient.invalidateQueries({
+ queryKey: attachmentReferencesKeys.list._def,
+ });
+ },
+ };
+}
diff --git a/apps/web/src/features/block-canvas/views/asset-picker.tsx b/apps/web/src/features/block-canvas/views/asset-picker.tsx
new file mode 100644
index 0000000000..4cae382c56
--- /dev/null
+++ b/apps/web/src/features/block-canvas/views/asset-picker.tsx
@@ -0,0 +1,254 @@
+import { MentionsMenuItem } from '@core/component/LexicalMarkdown/component/menu/MentionsMenu/components/MentionsMenuItem';
+import { createMentionPageLoader } from '@core/component/LexicalMarkdown/component/menu/MentionsMenu/hooks/createMentionPageLoader';
+import { useEntityMention } from '@core/component/LexicalMarkdown/component/menu/MentionsMenu/hooks/useEntityMention';
+import type { MentionItem } from '@core/component/LexicalMarkdown/utils/mentionsUtils';
+import { fileTypeToBlockName } from '@core/constant/allBlocks';
+import { fileDrop } from '@core/directive/fileDrop';
+import { debouncedDependent } from '@core/util/debounce';
+import SearchIcon from '@phosphor/magnifying-glass.svg';
+import UploadIcon from '@phosphor/upload-simple.svg';
+import { Button } from '@ui/components/Button';
+import {
+ ctrlJKMenuNavigation,
+ wrapIndex,
+} from '@ui/utils/menuKeyboardNavigation';
+import {
+ createEffect,
+ createMemo,
+ createSignal,
+ createUniqueId,
+ Show,
+} from 'solid-js';
+import { VList, type VListHandle } from 'virtua/solid';
+import type { CanvasAsset } from '../core/assets';
+import { type CanvasInsertMode, canInsertAsset } from '../core/insert';
+
+false && fileDrop;
+false && ctrlJKMenuNavigation;
+
+export function CanvasAssetPicker(props: {
+ mode: CanvasInsertMode;
+ onSelect: (asset: CanvasAsset) => void;
+ onFiles: (files: File[]) => void;
+ onClose: () => void;
+}) {
+ const [dragging, setDragging] = createSignal(false);
+ let fileInput: HTMLInputElement | undefined;
+ const [search, setSearch] = createSignal('');
+ const [index, setIndex] = createSignal(0);
+ const searchTerm = debouncedDependent(search, 60);
+ const source = useEntityMention({
+ buckets:
+ props.mode === 'media'
+ ? ['document']
+ : ['document', 'note', 'task', 'snippet', 'skill'],
+ searchTerm,
+ });
+ const items = createMemo(() =>
+ source
+ .entities()
+ .filter(
+ (item) =>
+ item.data.type === 'document' &&
+ item.data.fileType &&
+ canInsertAsset(props.mode, fileTypeToBlockName(item.data.fileType))
+ )
+ );
+ const selected = () => Math.min(index(), items().length - 1);
+ const loading = () =>
+ source.isLoading() || source.isLoadingMore() || search() !== searchTerm();
+ const listId = createUniqueId();
+ let list: VListHandle | undefined;
+ createEffect(() => {
+ const at = selected();
+ if (at >= 0) list?.scrollToIndex(at, { align: 'nearest' });
+ });
+ const pick = (item: MentionItem) => {
+ if (
+ item.kind !== 'entity' ||
+ item.data.type !== 'document' ||
+ !item.data.fileType
+ )
+ return;
+ props.onSelect({
+ id: item.id,
+ name: item.data.name,
+ fileType: item.data.fileType,
+ });
+ };
+ const loadPage = createMentionPageLoader();
+ // Page the shared mention source past non-matching file types, and prefetch
+ // near the selected row. The loader guards against an unchanged frontier.
+ createEffect(() => {
+ if (source.isLoading() || search() !== searchTerm()) return;
+ const raw = source.entities();
+ const needsPage = items().length < 8 || selected() >= items().length - 5;
+ loadPage({
+ bucket: {
+ id: 'documents',
+ hasMore: source.hasMore,
+ isLoadingMore: source.isLoadingMore,
+ loadMore: source.loadMore,
+ },
+ query: searchTerm(),
+ itemCount: raw.length,
+ selectedIndex: needsPage ? raw.length - 1 : -6,
+ });
+ });
+ return (
+ <div
+ class="flex h-full min-h-0 flex-col"
+ use:ctrlJKMenuNavigation={{ macOnly: false }}
+ on:keydown={(event) => {
+ if (event.key !== 'Tab') event.stopPropagation();
+ if (event.key === 'Escape') {
+ event.preventDefault();
+ props.onClose();
+ }
+ }}
+ >
+ <div class="flex shrink-0 items-center gap-2 border-b border-edge-muted px-3 py-2">
+ <SearchIcon class="size-4 shrink-0 text-ink-muted" />
+ <input
+ type="search"
+ role="combobox"
+ aria-label={`Search ${props.mode === 'media' ? 'media' : 'references'}`}
+ aria-expanded="true"
+ aria-autocomplete="list"
+ aria-controls={listId}
+ aria-activedescendant={
+ selected() >= 0 ? `${listId}-${selected()}` : undefined
+ }
+ placeholder={
+ props.mode === 'media' ? 'Find images or videos…' : 'Find a file…'
+ }
+ class="h-7 min-w-0 flex-1 bg-transparent text-sm outline-none placeholder:text-ink-placeholder"
+ value={search()}
+ onInput={(event) => {
+ setIndex(0);
+ setSearch(event.currentTarget.value);
+ }}
+ on:keydown={(event) => {
+ if (event.isComposing) return;
+ if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {
+ event.preventDefault();
+ const length = items().length;
+ if (length)
+ setIndex(
+ wrapIndex(
+ selected(),
+ length,
+ event.key === 'ArrowDown' ? 1 : -1
+ )
+ );
+ } else if (event.key === 'Enter') {
+ event.preventDefault();
+ const item = items()[selected()];
+ if (item && !loading()) pick(item);
+ }
+ }}
+ />
+ </div>
+ <Show when={props.mode === 'media'}>
+ <div
+ aria-label="Upload canvas media"
+ class="m-3 mb-1.5 flex min-h-44 shrink-0 flex-col items-center justify-center gap-3 rounded-lg border border-dashed border-edge-muted p-4 text-center"
+ classList={{ 'bg-hover': dragging() }}
+ use:fileDrop={{
+ multiple: true,
+ onDrop: props.onFiles,
+ onDragStart: setDragging,
+ onDragEnd: () => setDragging(false),
+ }}
+ >
+ <UploadIcon class="size-8 text-ink-extra-muted" />
+ <div>
+ <p class="text-sm text-ink">Drop files here</p>
+ <p class="mt-1 text-xs text-ink-muted">
+ Add images or videos to this canvas.
+ </p>
+ </div>
+ <Button
+ size="sm"
+ variant="outline"
+ onClick={() => fileInput?.click()}
+ >
+ Add files
+ </Button>
+ <input
+ ref={fileInput}
+ type="file"
+ multiple
+ accept="image/*,video/*,.heic,.heif"
+ aria-label="Choose canvas media"
+ class="hidden"
+ onChange={(event) => {
+ const files = Array.from(event.currentTarget.files ?? []);
+ if (files.length) props.onFiles(files);
+ event.currentTarget.value = '';
+ }}
+ />
+ </div>
+ </Show>
+ <div class="flex min-h-0 flex-1 flex-col py-1.5">
+ <div
+ id={listId}
+ role="listbox"
+ aria-label={`Available ${props.mode}`}
+ class="min-h-0 flex-1 overflow-hidden"
+ classList={{ hidden: !items().length }}
+ >
+ <VList
+ ref={(handle) => {
+ list = handle;
+ }}
+ data={items()}
+ itemSize={36}
+ class="overscroll-contain"
+ style={{ height: '100%' }}
+ >
+ {(item, itemIndex) => (
+ <div
+ id={`${listId}-${itemIndex()}`}
+ role="option"
+ aria-selected={selected() === itemIndex()}
+ >
+ <MentionsMenuItem
+ item={item}
+ disableScrollIntoView
+ index={itemIndex()}
+ selected={selected() === itemIndex()}
+ setIndex={setIndex}
+ itemAction={pick}
+ setOpen={(open) => {
+ if (!open) props.onClose();
+ }}
+ />
+ </div>
+ )}
+ </VList>
+ </div>
+ <Show when={loading()}>
+ <p role="status" class="px-3 py-2 text-xs text-ink-muted">
+ Loading files…
+ </p>
+ </Show>
+ <Show when={!items().length && !loading() && !source.hasMore()}>
+ <p role="status" class="px-3 py-3 text-xs text-ink-muted">
+ No matching files
+ </p>
+ </Show>
+ <Show when={source.hasMore()}>
+ <button
+ type="button"
+ class="w-full rounded px-3 py-2 text-xs text-ink-muted hover:bg-hover disabled:opacity-50"
+ disabled={loading()}
+ onClick={() => void source.loadMore()}
+ >
+ Load more
+ </button>
+ </Show>
+ </div>
+ </div>
+ );
+}
diff --git a/apps/web/src/features/block-canvas/views/canvas-context-menu.tsx b/apps/web/src/features/block-canvas/views/canvas-context-menu.tsx
index c30c66fb5c..b1ca2120f8 100644
--- a/apps/web/src/features/block-canvas/views/canvas-context-menu.tsx
+++ b/apps/web/src/features/block-canvas/views/canvas-context-menu.tsx
@@ -58,6 +58,12 @@ export function CanvasContextMenu(props: {
hotkeyToken={TOKENS.canvas.paste}
onClick={() => void props.clipboard.paste()}
/>
+ <MenuItem
+ text="Paste in place"
+ icon={Clipboard}
+ shortcut="shift+cmd+v"
+ onClick={() => void props.clipboard.paste(true)}
+ />
<MenuItem
text="Duplicate"
icon={Copy}
diff --git a/apps/web/src/features/block-canvas/views/canvas-read-only-view.tsx b/apps/web/src/features/block-canvas/views/canvas-read-only-view.tsx
index f96c38543a..d05f6bae52 100644
--- a/apps/web/src/features/block-canvas/views/canvas-read-only-view.tsx
+++ b/apps/web/src/features/block-canvas/views/canvas-read-only-view.tsx
@@ -20,6 +20,14 @@ export function CanvasReadOnlyView(props: {
}) {
const [tool, setTool] = createSignal<'select' | 'pan'>('select');
const [scale, setScale] = createSignal(props.editor.getCamera().scale);
+ const [hasSelection, setHasSelection] = createSignal(
+ props.editor.getSession().selectedIds.length > 0
+ );
+ onCleanup(
+ props.editor.subscribeSession((session) =>
+ setHasSelection(session.selectedIds.length > 0)
+ )
+ );
onCleanup(props.editor.subscribeCamera((camera) => setScale(camera.scale)));
let host!: HTMLDivElement;
const zoom = (factor: number) =>
@@ -36,6 +44,11 @@ export function CanvasReadOnlyView(props: {
width: host.clientWidth,
height: host.clientHeight,
});
+ const fitSelection = () =>
+ props.editor.fitSelection({
+ width: host.clientWidth,
+ height: host.clientHeight,
+ });
onMount(() => {
const observer = new ResizeObserver(([entry]) => {
if (!entry?.contentRect.width || !entry.contentRect.height) return;
@@ -65,8 +78,10 @@ export function CanvasReadOnlyView(props: {
return;
}
if (event.shiftKey) return;
- if (event.key === '.') fit();
- else if (event.key.toLowerCase() === 'v') setTool('select');
+ if (event.key === '.') {
+ if (hasSelection()) fitSelection();
+ else fit();
+ } else if (event.key.toLowerCase() === 'v') setTool('select');
else if (event.key.toLowerCase() === 'h') setTool('pan');
else return;
event.preventDefault();
@@ -114,7 +129,13 @@ export function CanvasReadOnlyView(props: {
focus();
}}
/>
- <CanvasZoomToolbar scale={scale()} onZoom={zoom} onFit={fit} />
+ <CanvasZoomToolbar
+ scale={scale()}
+ onZoom={zoom}
+ onFit={fit}
+ hasSelection={hasSelection()}
+ onFitSelection={fitSelection}
+ />
</div>
);
}
diff --git a/apps/web/src/features/block-canvas/views/canvas-toolbars.tsx b/apps/web/src/features/block-canvas/views/canvas-toolbars.tsx
index c9a66c0737..740f26676f 100644
--- a/apps/web/src/features/block-canvas/views/canvas-toolbars.tsx
+++ b/apps/web/src/features/block-canvas/views/canvas-toolbars.tsx
@@ -9,6 +9,7 @@ import Cursor from '@phosphor/cursor.svg';
import Eraser from '@phosphor/eraser.svg';
import Hand from '@phosphor/hand.svg';
import Minus from '@phosphor/minus.svg';
+import Paperclip from '@phosphor/paperclip.svg';
import Pencil from '@phosphor/pencil-simple.svg';
import Plus from '@phosphor/plus.svg';
import Rectangle from '@phosphor/rectangle.svg';
@@ -37,6 +38,8 @@ export function CanvasDrawingToolbar(props: {
tool: CanvasTool;
onTool: (tool: CanvasTool) => void;
readOnly?: boolean;
+ onAttach?: (anchor: { x: number; y: number }) => void;
+ attachOpen?: boolean;
}) {
return (
<div class="pointer-events-none absolute bottom-4 left-1/2 z-40 max-w-[calc(100%-2rem)] -translate-x-1/2">
@@ -68,6 +71,22 @@ export function CanvasDrawingToolbar(props: {
)}
</For>
</Toolbar.Group>
+ <Show when={!props.readOnly && props.onAttach}>
+ <Toolbar.Divider />
+ <Toolbar.Button
+ label="Attach"
+ shortcut="i"
+ tooltipDisabled={props.attachOpen}
+ aria-expanded={props.attachOpen ?? false}
+ aria-haspopup="menu"
+ onClick={(event) => {
+ const rect = event.currentTarget.getBoundingClientRect();
+ props.onAttach?.({ x: rect.left + rect.width / 2, y: rect.top });
+ }}
+ >
+ <Paperclip />
+ </Toolbar.Button>
+ </Show>
</Toolbar>
</div>
);
@@ -132,6 +151,8 @@ type CanvasZoomProps = {
scale: number;
onZoom: (factor: number) => void;
onFit: () => void;
+ hasSelection: boolean;
+ onFitSelection: () => void;
};
function CanvasZoomMenu(props: ParentProps<CanvasZoomProps>) {
@@ -160,7 +181,18 @@ function CanvasZoomMenu(props: ParentProps<CanvasZoomProps>) {
</Dropdown.Item>
<Dropdown.Item onSelect={props.onFit}>
<span class="flex-1">Zoom to fit</span>
- <Hotkey token={TOKENS.canvas.zoomFit} theme="subtle" />
+ <Show when={!props.hasSelection}>
+ <Hotkey token={TOKENS.canvas.zoomFit} theme="subtle" />
+ </Show>
+ </Dropdown.Item>
+ <Dropdown.Item
+ disabled={!props.hasSelection}
+ onSelect={props.onFitSelection}
+ >
+ <span class="flex-1">Zoom to fit selection</span>
+ <Show when={props.hasSelection}>
+ <Hotkey token={TOKENS.canvas.zoomFit} theme="subtle" />
+ </Show>
</Dropdown.Item>
</Dropdown.Group>
<Dropdown.Group>
@@ -216,6 +248,8 @@ export function CanvasViewControls(
scale={props.scale}
onZoom={props.onZoom}
onFit={props.onFit}
+ hasSelection={props.hasSelection}
+ onFitSelection={props.onFitSelection}
>
<Dropdown.Group>
<CanvasViewCheckboxItem checked={props.grid} onChange={props.onGrid}>
diff --git a/apps/web/src/features/block-canvas/views/canvas-view.tsx b/apps/web/src/features/block-canvas/views/canvas-view.tsx
index 84e4be2cc8..273e2f6ec5 100644
--- a/apps/web/src/features/block-canvas/views/canvas-view.tsx
+++ b/apps/web/src/features/block-canvas/views/canvas-view.tsx
@@ -29,13 +29,11 @@ import type { CanvasClipboard } from '../clipboard';
import { ConnectorInspector } from '../components/connector-inspector';
import type { CanvasEmbedViewProps } from '../components/embed-view';
import { EraserTrail } from '../components/eraser-trail';
+import { MediaUploadPreviews } from '../components/media-upload-previews';
import { SelectionLayoutInspector } from '../components/selection-layout-inspector';
import { StyleInspector } from '../components/style-inspector';
import { TextInspector } from '../components/text-inspector';
-import {
- canEmbedDocument,
- setDocumentDisplayCommand,
-} from '../core/document-display';
+import { setDocumentDisplayCommand } from '../core/document-display';
import {
selectionLayoutCommand,
selectionLayoutInfo,
@@ -47,6 +45,7 @@ import type {
CanvasState,
CanvasTool,
} from '../primitives/create-canvas-state';
+import type { CanvasInsertState } from '../primitives/create-insert-state';
import { attachTextInput } from '../primitives/text-input';
import { CanvasContextMenu } from './canvas-context-menu';
import {
@@ -56,6 +55,7 @@ import {
} from './canvas-toolbars';
import { ConnectorTargets } from './connector-targets';
import { CanvasDocumentView, CanvasMediaView } from './embedded-items';
+import { CanvasInsertMenu } from './insert-menu';
import { CanvasTextContent } from './text-content';
import { TextEditingView } from './text-editing-view';
@@ -66,6 +66,7 @@ export function CanvasView(props: {
embedView: Component<CanvasEmbedViewProps>;
clipboard: CanvasClipboard;
assets: CanvasAssetState;
+ insert: CanvasInsertState;
onViewport: (element: HTMLElement) => void;
onOpenDocument: (geometry: DocumentGeometry) => void;
attachScope: (element: Element) => void;
@@ -119,11 +120,9 @@ export function CanvasView(props: {
endHead: shared('endHead'),
};
};
- const inspectorWidth = () =>
- Math.min(288, Math.max(0, host.clientWidth - 48));
const fit = () => {
editor.fitScene({
- width: host.clientWidth - inspectorWidth(),
+ width: host.clientWidth,
height: host.clientHeight,
});
};
@@ -134,12 +133,19 @@ export function CanvasView(props: {
const zoom = (factor: number) =>
editor.zoomAt(
{
- x: (host.clientWidth - inspectorWidth()) / 2,
+ x: host.clientWidth / 2,
y: host.clientHeight / 2,
},
editor.getCamera().scale * factor
);
- registerCanvasZoomHotkeys(props.scopeId, state, zoom, fit);
+ const fitSelection = () =>
+ editor.fitSelection({
+ width: host.clientWidth,
+ height: host.clientHeight,
+ });
+ registerCanvasZoomHotkeys(props.scopeId, state, zoom, () =>
+ state.selection().length ? fitSelection() : fit()
+ );
const exitEmbed = () => {
state.embeds.exit();
focus();
@@ -177,6 +183,7 @@ export function CanvasView(props: {
});
props.attachScope(root);
props.onViewport(host);
+ onCleanup(props.insert.attach(host));
droppable(host);
onCleanup(props.clipboard.attach(root));
onCleanup(attachTextInput(root, state));
@@ -217,6 +224,25 @@ export function CanvasView(props: {
data-canvas-next
>
<main class="relative size-full overflow-hidden">
+ <Show when={props.insert.location()} keyed>
+ {(location) => (
+ <CanvasInsertMenu
+ location={location}
+ onClose={props.insert.close}
+ onRestoreFocus={focus}
+ onSelect={(asset, mode) => {
+ if (mode === 'media')
+ void props.assets.media(asset, location.world);
+ else props.assets.document(asset, location.world, 'preview');
+ props.insert.close();
+ }}
+ onFiles={(files) => {
+ void props.assets.files(files, location.world);
+ props.insert.close();
+ }}
+ />
+ )}
+ </Show>
<Show when={!sidePanel?.isOpen()}>
<Layer depth={2}>
<aside
@@ -240,6 +266,8 @@ export function CanvasView(props: {
onGrid={state.setGrid}
onZoom={zoom}
onFit={fit}
+ hasSelection={state.selection().length > 0}
+ onFitSelection={fitSelection}
snapMode={state.snapMode()}
onSnapMode={state.setSnapMode}
/>
@@ -403,7 +431,7 @@ export function CanvasView(props: {
const item = selectedItem();
return (
item?.type === 'document' &&
- canEmbedDocument(item.geometry.fileType)
+ item.geometry.display === 'embed'
);
})()}
>
@@ -416,20 +444,11 @@ export function CanvasView(props: {
state.embeds.exit();
editor.execute(setDocumentDisplayCommand, {
id: item.id,
- display:
- item.geometry.display === 'embed'
- ? 'preview'
- : 'embed',
+ display: 'preview',
});
}}
>
- {(() => {
- const item = selectedItem();
- return item?.type === 'document' &&
- item.geometry.display === 'embed'
- ? 'Use preview card'
- : 'Use full embed';
- })()}
+ Use preview card
</button>
</Show>
</Show>
@@ -538,12 +557,6 @@ export function CanvasView(props: {
embedView={props.embedView}
active={state.embeds.active() === itemProps.item.id}
onEnter={() => state.embeds.enter(itemProps.item.id)}
- onEmbed={() =>
- editor.execute(setDocumentDisplayCommand, {
- id: itemProps.item.id,
- display: 'embed',
- })
- }
onExit={exitEmbed}
/>
),
@@ -605,6 +618,10 @@ export function CanvasView(props: {
}
>
<EraserTrail points={state.eraser.trail()} />
+ <MediaUploadPreviews
+ previews={props.assets.previews()}
+ camera={state.camera()}
+ />
<Show
when={
(state.isConnectorTool() || state.connector.gesture()) &&
@@ -638,6 +655,8 @@ export function CanvasView(props: {
/>
</ContextMenu>
<CanvasDrawingToolbar
+ onAttach={props.insert.openFromToolbar}
+ attachOpen={!!props.insert.location()}
tool={state.tool()}
onTool={(tool) => {
state.chooseTool(tool);
diff --git a/apps/web/src/features/block-canvas/views/embedded-items.tsx b/apps/web/src/features/block-canvas/views/embedded-items.tsx
index 5eb89ce7af..63dbe272fd 100644
--- a/apps/web/src/features/block-canvas/views/embedded-items.tsx
+++ b/apps/web/src/features/block-canvas/views/embedded-items.tsx
@@ -5,18 +5,13 @@ import { staticFileIdEndpoint } from '@core/constant/servers';
import type { ShapeViewProps } from '@macro-inc/graphics/solid';
import { useBinaryDocumentQuery } from '@queries/storage/binary-document';
import { Card } from '@ui';
-import {
- type Component,
- createEffect,
- createSignal,
- ErrorBoundary,
- on,
- onCleanup,
- Show,
- Suspense,
-} from 'solid-js';
+import { type Component, ErrorBoundary, Show, Suspense } from 'solid-js';
import { Dynamic } from 'solid-js/web';
import type { CanvasEmbedViewProps } from '../components/embed-view';
+import {
+ CanvasMediaContent,
+ CanvasMediaSkeleton,
+} from '../components/media-content';
import { canEmbedDocument } from '../core/document-display';
export function CanvasMediaView(
@@ -36,32 +31,6 @@ export function CanvasMediaView(
if (value.type === 'static') return staticFileIdEndpoint(value.id);
return query.isSuccess ? query.data : undefined;
};
- const [failed, setFailed] = createSignal(false);
- const [video, setVideo] = createSignal<HTMLVideoElement>();
- createEffect(on(url, () => setFailed(false)));
- createEffect(
- on([video, () => props.playing], ([element, playing]) => {
- if (!element) return;
- if (!playing) {
- element.pause();
- return;
- }
- let cancelled = false;
- onCleanup(() => {
- cancelled = true;
- element.pause();
- });
- async function play() {
- try {
- await element!.play();
- } catch {
- if (!cancelled) props.onStop();
- }
- }
- void play();
- })
- );
- const unavailable = () => failed() || query.isError;
return (
<div
data-canvas-media={props.item.type}
@@ -73,55 +42,26 @@ export function CanvasMediaView(
'box-sizing': 'border-box',
}}
>
- <Suspense
- fallback={
- <div class="grid size-full place-items-center bg-hover text-sm">
- Loading media…
- </div>
- }
- >
- <Show
- when={url() && !unavailable()}
- fallback={
- <div class="grid size-full place-items-center border border-edge-muted bg-panel p-3 text-xs text-ink-muted">
- {unavailable() ? 'Media unavailable' : 'Loading media…'}
- </div>
- }
- >
- <Show
- when={props.item.type === 'image'}
- fallback={
- <video
- ref={setVideo}
- src={url()}
- preload="metadata"
- playsinline
- class="size-full object-fill"
- onError={() => setFailed(true)}
- onEnded={props.onStop}
- />
- }
- >
- <img
- src={url()}
- alt={props.item.geometry.name}
- draggable={false}
- class="size-full object-fill"
- onError={() => setFailed(true)}
- />
- </Show>
- </Show>
+ <Suspense fallback={<CanvasMediaSkeleton />}>
+ <CanvasMediaContent
+ url={url()}
+ type={props.item.type}
+ name={props.item.geometry.name}
+ unavailable={query.isError}
+ playing={props.playing}
+ onStop={props.onStop}
+ />
</Suspense>
</div>
);
}
+
export function CanvasDocumentView(
props: ShapeViewProps<'document'> & {
embedView: Component<CanvasEmbedViewProps>;
active: boolean;
onEnter: () => void;
onExit: () => void;
- onEmbed: () => void;
}
) {
const embedded = () =>
@@ -165,11 +105,6 @@ export function CanvasDocumentView(
params: {},
isOpenable: true,
}}
- previewInfo={{
- showPreview: canEmbedDocument(props.item.geometry.fileType),
- isPreviewable: true,
- handlePreviewToggle: props.onEmbed,
- }}
/>
</div>
}
diff --git a/apps/web/src/features/block-canvas/views/insert-menu.tsx b/apps/web/src/features/block-canvas/views/insert-menu.tsx
new file mode 100644
index 0000000000..1419175bde
--- /dev/null
+++ b/apps/web/src/features/block-canvas/views/insert-menu.tsx
@@ -0,0 +1,179 @@
+import { Popover } from '@kobalte/core/popover';
+import ImageIcon from '@phosphor/image.svg';
+import LinkIcon from '@phosphor/link.svg';
+import UploadIcon from '@phosphor/upload-simple.svg';
+import { Dropdown } from '@ui';
+import { createSignal, ErrorBoundary, Show, Suspense } from 'solid-js';
+import { CanvasInsertRadialMenu } from '../components/insert-radial-menu';
+import type { CanvasAsset } from '../core/assets';
+import type { CanvasInsertMode } from '../core/insert';
+import type { CanvasInsertLocation } from '../primitives/create-insert-state';
+import { CanvasAssetPicker } from './asset-picker';
+
+export function CanvasInsertMenu(props: {
+ location: CanvasInsertLocation;
+ onSelect: (asset: CanvasAsset, mode: CanvasInsertMode) => void;
+ onFiles: (files: File[]) => void;
+ onClose: () => void;
+ onRestoreFocus: () => void;
+}) {
+ let uploadInput: HTMLInputElement | undefined;
+ const [mode, setMode] = createSignal<CanvasInsertMode>();
+ const anchor = () => ({ ...props.location.screen, width: 0, height: 0 });
+ return (
+ <>
+ <input
+ ref={uploadInput}
+ type="file"
+ class="hidden"
+ multiple
+ accept="image/*,video/*,.heic,.heif"
+ aria-label="Upload media"
+ onCancel={props.onClose}
+ onChange={(event) => {
+ const files = Array.from(event.currentTarget.files ?? []);
+ if (files.length) props.onFiles(files);
+ else props.onClose();
+ }}
+ />
+ <Show
+ when={mode()}
+ keyed
+ fallback={
+ <Show
+ when={props.location.presentation === 'dropdown'}
+ fallback={
+ <Popover
+ open
+ placement="bottom-start"
+ getAnchorRect={() => ({
+ x: 0,
+ y: 0,
+ width: 0,
+ height: 0,
+ })}
+ gutter={0}
+ flip={false}
+ overflowPadding={0}
+ onOpenChange={(open) => {
+ if (!open) props.onClose();
+ }}
+ >
+ <Popover.Portal>
+ <Popover.Content
+ class="z-action-menu outline-none"
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ if (!mode()) props.onRestoreFocus();
+ }}
+ >
+ <Popover.Title class="sr-only">Insert</Popover.Title>
+ <CanvasInsertRadialMenu
+ center={props.location.screen}
+ onMedia={() => setMode('media')}
+ onReference={() => setMode('reference')}
+ onUpload={() => uploadInput?.click()}
+ />
+ </Popover.Content>
+ </Popover.Portal>
+ </Popover>
+ }
+ >
+ <Dropdown
+ open
+ placement="top"
+ getAnchorRect={anchor}
+ onOpenChange={(open) => {
+ if (!open && !mode()) props.onClose();
+ }}
+ >
+ <Dropdown.Content
+ class="w-48"
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ if (!mode()) props.onRestoreFocus();
+ }}
+ >
+ <Dropdown.Group>
+ <Dropdown.Item onSelect={() => setMode('media')}>
+ <ImageIcon class="size-4" /> Media
+ </Dropdown.Item>
+ <Dropdown.Item
+ closeOnSelect={false}
+ onSelect={() => uploadInput?.click()}
+ >
+ <UploadIcon class="size-4" /> Upload media
+ </Dropdown.Item>
+ <Dropdown.Item onSelect={() => setMode('reference')}>
+ <LinkIcon class="size-4" /> Reference
+ </Dropdown.Item>
+ </Dropdown.Group>
+ </Dropdown.Content>
+ </Dropdown>
+ </Show>
+ }
+ >
+ {(type) => (
+ <Popover
+ open
+ placement={
+ props.location.presentation === 'dropdown'
+ ? 'top'
+ : 'bottom-start'
+ }
+ getAnchorRect={anchor}
+ gutter={4}
+ fitViewport
+ overflowPadding={8}
+ onOpenChange={(open) => {
+ if (!open) props.onClose();
+ }}
+ >
+ <Popover.Portal>
+ <Popover.Content
+ class="menu-surface z-action-menu flex w-80 max-w-[calc(100vw-1rem)] min-h-0 flex-col rounded-xl text-sm outline-none"
+ style={{
+ height: type === 'media' ? '28rem' : '21rem',
+ 'max-height':
+ 'min(28rem, var(--kb-popper-content-available-height, calc(100dvh - 1rem)))',
+ }}
+ onCloseAutoFocus={(event) => {
+ event.preventDefault();
+ if (mode()) props.onRestoreFocus();
+ }}
+ >
+ <Popover.Title class="sr-only">Insert {type}</Popover.Title>
+ <ErrorBoundary
+ fallback={(_, reset) => (
+ <button
+ type="button"
+ class="p-3 text-ink-muted"
+ onClick={reset}
+ >
+ Could not load files. Try again
+ </button>
+ )}
+ >
+ <Suspense
+ fallback={
+ <p role="status" class="p-3 text-ink-muted">
+ Loading files…
+ </p>
+ }
+ >
+ <CanvasAssetPicker
+ mode={type}
+ onSelect={(asset) => props.onSelect(asset, type)}
+ onFiles={props.onFiles}
+ onClose={props.onClose}
+ />
+ </Suspense>
+ </ErrorBoundary>
+ </Popover.Content>
+ </Popover.Portal>
+ </Popover>
+ )}
+ </Show>
+ </>
+ );
+}
diff --git a/apps/web/src/features/drive-view/components/DriveDetailView.tsx b/apps/web/src/features/drive-view/components/DriveDetailView.tsx
index 6c5da3b42e..334fc10147 100644
--- a/apps/web/src/features/drive-view/components/DriveDetailView.tsx
+++ b/apps/web/src/features/drive-view/components/DriveDetailView.tsx
@@ -21,12 +21,12 @@ import { ErrorBoundary, For, Match, Show, Switch } from 'solid-js';
import { useDriveView } from '../context/drive-context';
import { driveLocationBreadcrumbs } from '../core/breadcrumbs';
import { useDriveDetailNavigation } from '../drive-detail-navigation';
+import { FileDetailBreadcrumbItem } from '../views/FileDetailBreadcrumbItem';
import {
MarkdownDetail,
MarkdownDetailBodyState,
} from '../views/MarkdownDetail';
import { DriveBreadcrumbsOutlet } from './DriveBreadcrumbs';
-import { FileDetailBreadcrumbItem } from './FileDetailBreadcrumbItem';
function DriveDetailAncestorBreadcrumbs(props: { orderOffset: number }) {
const navigationStack = useDriveDetailNavigation();
diff --git a/apps/web/src/features/drive-view/components/FileDetailBreadcrumbItem.tsx b/apps/web/src/features/drive-view/views/FileDetailBreadcrumbItem.tsx
similarity index 93%
rename from apps/web/src/features/drive-view/components/FileDetailBreadcrumbItem.tsx
rename to apps/web/src/features/drive-view/views/FileDetailBreadcrumbItem.tsx
index 26fe8b06a9..db528e5e51 100644
--- a/apps/web/src/features/drive-view/components/FileDetailBreadcrumbItem.tsx
+++ b/apps/web/src/features/drive-view/views/FileDetailBreadcrumbItem.tsx
@@ -11,6 +11,7 @@ import type { BlockAlias, BlockName } from '@core/block';
import { EntityIcon } from '@core/component/EntityIcon';
import { getPermissions } from '@core/component/SharePermissions';
import { buildEntityData } from '@entity';
+import { useItemRawName } from '@queries/preview';
import type { AccessLevel } from '@service-storage/generated/schemas/accessLevel';
import type { DocumentMetadata } from '@service-storage/generated/schemas/documentMetadata';
@@ -35,8 +36,15 @@ export function FileDetailBreadcrumbItem(props: {
{ op: 'delete' },
];
const documentId = () => props.documentMetadata.documentId;
+ const liveName = useItemRawName(() => ({
+ id: documentId(),
+ type: 'document',
+ }));
const documentName = () =>
- props.documentMetadata.documentName ?? props.fallbackName ?? 'Untitled';
+ liveName() ??
+ props.documentMetadata.documentName ??
+ props.fallbackName ??
+ 'Untitled';
useSplitDisplayName(documentName);
useBlockEntityCommands({
diff --git a/docs/agent-guide/documents.md b/docs/agent-guide/documents.md
index 1adb04ca77..5b3da31337 100644
--- a/docs/agent-guide/documents.md
+++ b/docs/agent-guide/documents.md
@@ -50,7 +50,9 @@ old snippet toggle provided, or **None** to remove team access.
Hover or focus a document title in the header to see its owner, created time,
and last-updated time. This details card is shared
by documents, tasks, snippets, canvas, and file blocks; unavailable metadata is
-labeled rather than inferred.
+labeled rather than inferred. Canvas and file breadcrumb names follow live
+renames, including the tab title and title menu. Rename an open canvas and confirm
+its header updates immediately without reloading or remounting the editor.
Editable documents show matching **Add tags** and **Add property** pills below
the title. Once tags are applied, **Add tags** becomes the existing tag name or
@@ -74,6 +76,13 @@ embeds and check that their preview bodies load; also check that a code or canva
mention offers **Convert to Embed** in its preview menu.
Drag an embed's bottom-right resize grip, then release and select the card. Its
height should stay at the dragged size and persist after reopening the document.
+Zoom to fit and menu/keyboard zoom use the full canvas viewport center; floating
+inspectors and details overlays do not reserve centering space. Verify with content
+on both sides of the canvas and the inspector visible. Press **.** to fit the
+current selection, or all content when nothing is selected. The zoom menu keeps
+**Zoom to fit** for all content and adds **Zoom to fit selection**, disabled with
+no selection. Verify one item and multiple selected items, then deselect and
+check that **.** fits everything again.
All canvases open in Canvas Next, including drive details and Markdown embeds;
there is no rollout flag or legacy editor. Unversioned/version 1 files migrate
in memory. Opening a file alone does not save the migration; the first edit saves
@@ -82,6 +91,56 @@ records and unknown versions show an error without changing the saved file.
To verify migration, open a supported legacy canvas, edit it, then reopen it and
check that its shapes, text, and connectors remain intact.
+Canvas spatial paste keeps the layout of the copied selection. Copying from another
+canvas, or pasting Excalidraw data, centers the selection in the current viewport
+at the current pan/zoom. Same-canvas copies retain the cumulative 24-unit paste
+offset, including copies from another tab of that document. Shift+Cmd/Ctrl+V (or
+**Paste in place** in the context menu) keeps original world coordinates and
+bypasses grid snapping. Verify cross-canvas, same-canvas repeated paste, and
+Shift-paste with a grouped selection; ordinary text/editor paste is unchanged.
+
+The editable drawing toolbar has a paperclip **Attach** button with an **I**
+shortcut hint. Clicking it opens a standard dropdown for **Media**, **Upload
+media**, and **Reference**. Its pickers open above the toolbar; attachments land
+at the canvas center. Verify clicking Attach, choosing each type, and Escape.
+The Attach tooltip stays hidden while the insertion menu or picker is open.
+Radial menu buttons retain an opaque surface when their slice is highlighted.
+
+With an editable canvas focused, press **I** to open a radial menu of separate floating buttons around the mouse
+position: **Media**, **Upload media**, and **Reference**. Equal directional slices
+highlight the corresponding button and ring arc on pointer movement; clicking
+anywhere in the viewport selects the active slice, including well beyond the
+buttons; outside clicks do not dismiss the radial menu. Escape closes it. The center is a neutral dead zone. Media and Reference
+replace the radial menu with searchable mentions-style pickers. Upload media
+opens the OS picker directly for local images/videos. References insert document
+preview cards; creating new embeds is unavailable. Arrow keys or Ctrl+J/K navigate;
+Enter selects and Escape closes. Selected rows scroll with the same inset as the
+menu padding. Picker height stays fixed through loading, search results, and no
+results, capped by the available viewport space. Verify typing an unmatched query
+and clearing it does not move the search field or resize the menu.
+Media retains its dashed drop area and **Add files** button, with no
+folder option. Insertion uses the position captured when I is pressed. Verify
+keyboard selection, closing/reopening, upload cancellation, and placement after
+pan/zoom. The shortcut is inactive during text/embed editing and in read-only canvases.
+Reference cards register with the shared reference system when the canvas saves.
+Verify the backlink on the target, duplicate cards retaining one reference, and
+removing the final card followed by undo/redo. Reload must preserve tracking.
+Existing untracked cards register on their next content save.
+Pasting a same-host Macro file URL uses the same link resolver as Markdown and
+inserts a reference card at the viewport center, including nested Drive routes
+and copied split layouts (the rightmost pane). Legacy `/app/md/<id>` links still
+work. Verify a `/app/drive/md/<id>` paste becomes a card and registers a backlink;
+foreign-host links and unrecognized routes remain text.
+
+Pasting or dropping image files shows local previews while the static-file upload
+finishes. Previews become selectable image nodes after upload and remote loading
+succeed; a failed upload removes its preview and reports the failure. Verify with
+a slow upload, then undo/redo the inserted batch and reopen the canvas. Blob URLs
+must never enter the saved scene. When opening a canvas, image nodes show a
+`skeleton-shimmer bg-skeleton` placeholder at their saved size until the image
+loads; this also applies to read-only embeds. Failed image requests display
+“Media unavailable” instead of an indefinite skeleton.
+
Canvas embeds are read-only: **Select** selects shapes without moving them,
and **Hand** pans the canvas. The toolbar contains only those two tools; property
inspector details and drawing/editing controls are absent. Check toolbar clicks,
diff --git a/packages/graphics/src/core/editor.ts b/packages/graphics/src/core/editor.ts
index 3283e7c1e8..7640be5c7d 100644
--- a/packages/graphics/src/core/editor.ts
+++ b/packages/graphics/src/core/editor.ts
@@ -1,3 +1,4 @@
+import { enclosing } from './affine';
import type { GraphicsBackend } from './backend';
import {
fitImageCamera,
@@ -36,6 +37,7 @@ import {
freezeDocument,
groupNodes,
hitTest,
+ nodeBoundsPoints,
reparent,
ungroupNode,
worldBounds,
@@ -227,6 +229,34 @@ function createEditor(
for (const listener of listeners) listener(camera);
}
+ function fitBounds(
+ bounds: Bounds,
+ viewport: { width: number; height: number }
+ ) {
+ if (
+ (bounds.width <= 0 && bounds.height <= 0) ||
+ ![viewport.width, viewport.height].every(
+ (size) => Number.isFinite(size) && size > 0
+ )
+ )
+ return;
+ // Screen-space margins; leave usable room even in a small embedded view.
+ const padding = Math.min(100, viewport.width / 4, viewport.height / 4);
+ const scale = Math.max(
+ MIN_SCALE,
+ Math.min(
+ MAX_SCALE,
+ (viewport.width - padding * 2) / bounds.width,
+ (viewport.height - padding * 2) / bounds.height
+ )
+ );
+ publish({
+ scale,
+ x: (viewport.width - bounds.width * scale) / 2 - bounds.x * scale,
+ y: (viewport.height - bounds.height * scale) / 2 - bounds.y * scale,
+ });
+ }
+
function beginShape(kind: DrawingKind, point: DrawingSample) {
if (disposed || !Number.isFinite(point.x) || !Number.isFinite(point.y))
return false;
@@ -394,29 +424,13 @@ function createEditor(
},
fitScene(viewport: { width: number; height: number }) {
const bounds = worldBounds(document, document.rootId);
- if (
- bounds.width <= 0 ||
- bounds.height <= 0 ||
- ![viewport.width, viewport.height].every(
- (size) => Number.isFinite(size) && size > 0
- )
- )
- return;
- // Screen-space margins; leave usable room even in a small embedded view.
- const padding = Math.min(100, viewport.width / 4, viewport.height / 4);
- const scale = Math.max(
- MIN_SCALE,
- Math.min(
- MAX_SCALE,
- (viewport.width - padding * 2) / bounds.width,
- (viewport.height - padding * 2) / bounds.height
- )
- );
- publish({
- scale,
- x: (viewport.width - bounds.width * scale) / 2 - bounds.x * scale,
- y: (viewport.height - bounds.height * scale) / 2 - bounds.y * scale,
- });
+ fitBounds(bounds, viewport);
+ },
+ fitSelection(viewport: { width: number; height: number }) {
+ const points = selection
+ .getState()
+ .selectedIds.flatMap((id) => nodeBoundsPoints(document, id));
+ if (points.length) fitBounds(enclosing(points), viewport);
},
fitImage(viewport: { width: number; height: number }) {
if (document.surface) publish(fitImageCamera(document.surface, viewport));
diff --git a/packages/graphics/tests/core.test.ts b/packages/graphics/tests/core.test.ts
index a5acbd55ec..8c38a01255 100644
--- a/packages/graphics/tests/core.test.ts
+++ b/packages/graphics/tests/core.test.ts
@@ -4,6 +4,7 @@ import {
MAX_SCALE,
MIN_SCALE,
screenToWorld,
+ translation,
worldToScreen,
zoomAt,
} from '../src/core';
@@ -14,19 +15,20 @@ describe('camera', () => {
const point = { x: -1500, y: 808 };
expect(screenToWorld(camera, worldToScreen(camera, point))).toEqual(point);
});
- it.each([
- 0.0001, 0.3, 2, 100,
- ])('preserves the world point at the zoom anchor (%s)', (scale) => {
- const camera = { x: 32, y: -18, scale: 1.5 };
- const anchor = { x: 241, y: 173 };
- const next = zoomAt(camera, anchor, scale);
- const before = screenToWorld(camera, anchor);
- const after = screenToWorld(next, anchor);
- expect(after.x).toBeCloseTo(before.x);
- expect(after.y).toBeCloseTo(before.y);
- expect(next.scale).toBeGreaterThanOrEqual(MIN_SCALE);
- expect(next.scale).toBeLessThanOrEqual(MAX_SCALE);
- });
+ it.each([0.0001, 0.3, 2, 100])(
+ 'preserves the world point at the zoom anchor (%s)',
+ (scale) => {
+ const camera = { x: 32, y: -18, scale: 1.5 };
+ const anchor = { x: 241, y: 173 };
+ const next = zoomAt(camera, anchor, scale);
+ const before = screenToWorld(camera, anchor);
+ const after = screenToWorld(next, anchor);
+ expect(after.x).toBeCloseTo(before.x);
+ expect(after.y).toBeCloseTo(before.y);
+ expect(next.scale).toBeGreaterThanOrEqual(MIN_SCALE);
+ expect(next.scale).toBeLessThanOrEqual(MAX_SCALE);
+ }
+ );
it('isolates instances, rejects nonfinite input and stops notifications after disposal', () => {
const first = createGraphicsEditor();
const second = createGraphicsEditor();
@@ -42,3 +44,52 @@ describe('camera', () => {
expect(listener).toHaveBeenCalledTimes(1);
});
});
+
+describe('fit selection', () => {
+ function editorWithRectangles() {
+ return createGraphicsEditor(
+ [0, 300, 5000].map((x, index) => ({
+ id: String(index),
+ type: 'rectangle' as const,
+ placement: { parentId: 'scene-root', sortKey: `a${index}` },
+ transform: translation(x, 50),
+ geometry: { width: 100, height: 100 },
+ appearance: { fill: 'transparent', stroke: 'black' },
+ }))
+ );
+ }
+
+ it('fits only selected geometry and preserves selection and history', () => {
+ const editor = editorWithRectangles();
+ editor.select('0');
+ editor.toggleSelection('1');
+ const session = editor.getSession();
+ editor.fitSelection({ width: 1000, height: 800 });
+ expect(editor.getCamera()).toEqual({ x: 100, y: 200, scale: 2 });
+ expect(editor.getSession()).toEqual(session);
+ editor.fitScene({ width: 1000, height: 800 });
+ expect(editor.getCamera().scale).toBeCloseTo(800 / 5100);
+ });
+
+ it('includes descendants of a selected group', () => {
+ const editor = editorWithRectangles();
+ editor.select('0');
+ editor.toggleSelection('1');
+ editor.groupSelection('group');
+ editor.fitSelection({ width: 1000, height: 800 });
+ expect(editor.getCamera()).toEqual({ x: 100, y: 200, scale: 2 });
+ });
+
+ it('does nothing without a selection or a valid viewport', () => {
+ const editor = editorWithRectangles();
+ editor.panBy({ x: 34, y: 56 });
+ const camera = editor.getCamera();
+ editor.fitSelection({ width: 1000, height: 800 });
+ expect(editor.getCamera()).toEqual(camera);
+ editor.select('0');
+ for (const width of [0, -10, NaN, Infinity]) {
+ editor.fitSelection({ width, height: 800 });
+ expect(editor.getCamera()).toEqual(camera);
+ }
+ });
+});