Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
/**
* The `.fig` viewer: layers on the left, the canvas in the middle, the
* design panel on the right, Figma's keyboard shortcuts throughout.
*/
import '../components/editor-theme.css';
import { IS_MAC } from '@core/constant/isMac';
import type { NodeInfo, Rect } from '@core/fig-engine/types';
import { fireAndForget } from '@core/util/fireAndForget';
import { Tabs } from '@kobalte/core/tabs';
import { Telemetry } from '@macro-inc/observability';
import {
createEffect,
createSignal,
For,
on,
onCleanup,
onMount,
Show,
} from 'solid-js';
import { match } from 'ts-pattern';
import { ActionsPalette } from '../components/actions-palette';
import { CommentPins } from '../components/comment-pins';
import { DesignPanel } from '../components/design-panel';
import { DevInspect } from '../components/dev-inspect';
import { ExportSection } from '../components/export-section';
import { FigContextMenu } from '../components/fig-context-menu';
import { LayoutGridSection } from '../components/layout-grid-section';
import { MainMenu } from '../components/main-menu';
import { MissingFonts } from '../components/missing-fonts';
import { PanelToggle } from '../components/panel-toggle';
import { FollowFrame, PeerAvatars } from '../components/peer-presence';
import { PrototypeNoodles } from '../components/prototype-noodles';
import { PrototypePanel } from '../components/prototype-panel';
import { ResizablePanel } from '../components/resizable-panel';
import { CommentButton, PresentButton } from '../components/review-buttons';
import { SaveIndicator } from '../components/save-indicator';
import { ShortcutsDialog } from '../components/shortcuts-dialog';
import { ViewerToolbar } from '../components/viewer-toolbar';
import { ViewerZoom } from '../components/viewer-zoom';
import { useFigViewerContext } from '../context/fig-viewer-context';
import { type Point, zoomLabel } from '../core/camera';
import { LIBRARY_ASSET_MIME } from '../core/libraries';
import { MIXED, type MixedInfo, mergeInfos } from '../core/mixed';
import { stepPage } from '../core/pages';
import { type FigPeer, storesFile } from '../core/presence';
import { rangeFills, rangeStyle, textInfoForRange } from '../core/rich-text';
import {
controlOwnsKey,
EDIT_ACTIONS,
SELECTION_ACTIONS,
shortcutAction,
type ViewerAction,
} from '../core/shortcuts';
import { deleteVertex, VECTOR_EDITABLE } from '../core/vector';
import { createDesignSystem } from '../primitives/create-design-system';
import { createFigContextMenu } from '../primitives/create-fig-context-menu';
import { createFigEditor, type Patch } from '../primitives/create-fig-editor';
import { createFigLibraries } from '../primitives/create-fig-libraries';
import { createFigReview } from '../primitives/create-fig-review';
import { createFigViewer } from '../primitives/create-fig-viewer';
import { createFontRegistry } from '../primitives/create-font-registry';
import { createHandoff } from '../primitives/create-handoff';
import { createLayoutAids } from '../primitives/create-layout-aids';
import { createPeerOverlays } from '../primitives/create-peer-overlays';
import { AssetsPanel } from './assets-panel';
import { CommentsPanel } from './comments-panel';
import {
DesignSystemSections,
LocalStylesView,
styleControlFor,
} from './design-system-view';
import { LayersPanel } from './layers-panel';
import { LibraryUpdates } from './library-views';
import { PresentMode } from './present-mode';
import { TextEditor } from './text-editor';
import { ViewerCanvas } from './viewer-canvas';
/** How soon a second digit must follow the first to make an exact opacity. */
const OPACITY_TYPING_MS = 600;
const safeName = (name: string) =>
name.replace(/[\\/:*?"<>|]+/g, '-').trim() || 'export';
export function FigViewer() {
const context = useFigViewerContext();
const { engine } = context;
const viewer = createFigViewer({
engine,
notifyError: context.notifyError,
});
let invalidate: ((rect: Rect) => void) | undefined;
const collab = context.collaboration;
const editor = createFigEditor({
engine,
viewer,
canEdit: () => context.canEdit?.() ?? false,
save: context.save,
fileKey: context.fileKey,
onDirty: (rect) => invalidate?.(rect),
notifyError: context.notifyError,
sharing: context.sharing,
stores: collab
? () =>
storesFile(
{ peerId: collab.peerId, editor: context.canEdit?.() ?? false },
collab.peers()
)
: undefined,
online: collab ? () => collab.status() === 'connected' : undefined,
});
/**
* Edits whose engine reads (hit tests, layer rows) run before the editor's
* queue, which is where edit failures are otherwise reported.
*/
const runEdit = async (work: Promise<unknown>) => {
try {
await work;
} catch (error) {
Telemetry.error(error, { surface: 'fig-viewer' });
context.notifyError(
error instanceof Error ? error.message : String(error)
);
}
};
const review = createFigReview({
context,
engine,
viewer,
editor,
mac: IS_MAC,
});
const [spaceHeld, setSpaceHeld] = createSignal(false);
const [altHeld, setAltHeld] = createSignal(false);
const [deepHeld, setDeepHeld] = createSignal(false);
const [showShortcuts, setShowShortcuts] = createSignal(false);
const [showActions, setShowActions] = createSignal(false);
const [leftWidth, setLeftWidth] = createSignal(280);
const [rightWidth, setRightWidth] = createSignal(240);
const [leftTab, setLeftTab] = createSignal<'layers' | 'assets'>('layers');
const [info, setInfo] = createSignal<NodeInfo>();
const designSystem = createDesignSystem({ engine, viewer, editor });
const librarySource = context.libraries;
const libraries = librarySource
? createFigLibraries({
engine,
viewer,
editor,
source: librarySource,
notifyError: context.notifyError,
notifyInfo: context.notifyInfo,
})
: undefined;
const styleControl = styleControlFor(designSystem);
/** Dev Mode: the design panel shows the Code tab. */
const devMode = () =>
!viewer.uiHidden() && viewer.designOpen() && review.panelTab() === 'code';
const aids = createLayoutAids({ engine, viewer, editor, devMode, info });
const handoff = createHandoff({
context,
engine,
viewer,
editor,
info,
devMode,
});
let root!: HTMLDivElement;
let focusSearch: (() => void) | undefined;
onMount(() => {
fireAndForget(viewer.openPage(0), 'fig-viewer');
if (document.activeElement === document.body)
root.focus({ preventScroll: true });
});
// The design panel follows a single selection (and edits to it).
let infoRequest = 0;
createEffect(
on([viewer.selected, viewer.editVersion], ([selected]) => {
const request = ++infoRequest;
if (selected.length !== 1) {
setInfo(undefined);
return;
}
engine
.nodeInfo(viewer.page(), selected[0].id)
.then((i) => {
if (request === infoRequest) setInfo(i);
})
.catch(() => {
if (request === infoRequest) setInfo(undefined);
});
})
);
// ---- design panel ---------------------------------------------------------
// Several selected layers: their shared and mixed values.
const [mixed, setMixed] = createSignal<MixedInfo>();
// Fonts for laying out edited text; what the document uses changes as
// it is edited.
const fonts = createFontRegistry({ engine, source: context.fonts });
createEffect(
on(
viewer.editsSettled,
() => fireAndForget(fonts.refresh(), 'fig-viewer'),
{ defer: true }
)
);
let mixedRequest = 0;
const loadMixed = async (ids: string[], request: number) => {
try {
const infos = await Promise.all(
ids.slice(0, 200).map((id) => engine.nodeInfo(viewer.page(), id))
);
if (request === mixedRequest) setMixed(mergeInfos(infos));
} catch {
if (request === mixedRequest) setMixed(undefined);
}
};
createEffect(
on([viewer.selected, viewer.editsSettled], ([selected]) => {
const request = ++mixedRequest;
if (selected.length < 2) setMixed(undefined);
else
fireAndForget(
loadMixed(
selected.map((s) => s.id),
request
),
'fig-viewer'
);
})
);
// A drag in the design panel (scrubbing a value, a color) sends live
// edits and commits on release: one undo step per drag.
let gesture: { what: string; key: string } | undefined;
let gestures = 0;
const gestureKey = (what: string, live: boolean) => {
if (gesture?.what !== what)
gesture = live ? { what, key: `panel-${what}-${++gestures}` } : undefined;
const key = gesture?.key;
if (!live) gesture = undefined;
return key;
};
/**
* A panel change: to the characters selected in the text editor when
* there are some, after loading a font it switches to.
*/
const patchSelection = (patch: Patch, live: boolean) => {
const what = gestureKey(Object.keys(patch).join(','), live);
const range = editor.textSelection();
const ranged =
range && range.start !== range.end && range.id === info()?.id
? { ...patch, textRange: [range.start, range.end] as [number, number] }
: patch;
const text = info()?.text;
if (!text || (!patch.fontFamily && !patch.fontStyle)) {
fireAndForget(editor.setProps(ranged, what), 'fig-viewer');
return;
}
const style = rangeStyle(text, range?.start ?? 0, range?.end ?? 0);
const family =
patch.fontFamily ??
(style.fontFamily === MIXED ? text.fontFamily : style.fontFamily) ??
'Inter';
const fontStyle =
patch.fontStyle ??
(style.fontStyle === MIXED ? null : style.fontStyle) ??
'Regular';
fireAndForget(
(async () => {
await fonts.ensure(family, fontStyle, text.characters);
await editor.setProps(ranged, what);
await fonts.refresh();
})(),
'fig-viewer'
);
};
/**
* A lifted move being dragged (the canvas draws it) and the layer's values
* from before it, which the panel shows moved along until the values
* after the drop arrive (`until`: the values shown at the drop).
*/
const [moving, setMoving] = createSignal<{
offset: Point;
from: NodeInfo | undefined;
until?: NodeInfo;
}>();
const onMove = (offset: Point | undefined) => {
const m = moving();
if (offset) setMoving({ offset, from: m && !m.until ? m.from : info() });
else if (m) setMoving({ ...m, until: info() });
};
const movedInfo = () => {
const i = info();
const m = moving();
const from = m?.from;
if (!i || !m || !from || viewer.selected().length !== 1) return i;
if (i.id !== from.id || (m.until && i !== m.until)) return i;
const [a, b, c, d] = from.panelMove;
const { x: dx, y: dy } = m.offset;
return {
...i,
x: from.x + a * dx + b * dy,
y: from.y + c * dx + d * dy,
bounds: { ...from.bounds, x: from.bounds.x + dx, y: from.bounds.y + dy },
};
};
/** The design panel's layer, showing the text editor's selection. */
const panel = () => {
const i = movedInfo();
const range = editor.textSelection();
if (!i?.text || !range || range.id !== i.id || range.start === range.end)
return { info: i, mixed: undefined };
const { text, mixed } = textInfoForRange(i.text, range.start, range.end);
const fills = rangeFills(i.text, range.start, range.end);
return {
info: { ...i, text, fills: fills && fills !== MIXED ? fills : i.fills },
mixed,
};
};
const shownFamily = () => panel().info?.text?.fontFamily ?? undefined;
const setPageColor = (hex: string, live: boolean) => {
const page = viewer.pages[viewer.page()];
if (!page) return;
fireAndForget(
editor.apply(
[{ op: 'set', ids: [page.id], props: { fills: [{ color: hex }] } }],
gestureKey('page-color', live)
),
'fig-viewer'
);
};
/** The page's colors, offered by the color pickers (loaded on opening). */
const [swatches, setSwatches] = createSignal<string[]>([]);
const loadSwatches = async () => {
try {
setSwatches(await engine.pageColors(viewer.page()));
} catch {
setSwatches([]);
}
};
const addImage = async (file: File) => {
try {
return (await engine.addImage(await file.arrayBuffer())).hash;
} catch (e) {
context.notifyError(
e instanceof Error ? e.message : `${file.name} could not be added`
);
return undefined;
}
};
// ---- export -------------------------------------------------------------
const copyPng = async () => {
const id = viewer.selected()[0]?.id;
if (!id) {
context.notifyInfo('Select a layer to copy');
return;
}
try {
const png = engine.exportPng(viewer.page(), id, 2);
await navigator.clipboard.write([
new ClipboardItem({ 'image/png': png }),
]);
context.notifyInfo('Copied as PNG');
} catch {
context.notifyError('Could not copy the image');
}
};
/** The single selected layer as an SVG document. */
const selectedSvg = async (): Promise<
{ svg: string; name: string } | undefined
> => {
const id = viewer.selected()[0]?.id;
if (!id) {
context.notifyInfo('Select a layer to export');
return undefined;
}
const name = info()?.id === id ? info()?.name : undefined;
return {
svg: await engine.exportSvg(viewer.page(), id),
name: safeName(name ?? `${context.fileName()}-${id}`),
};
};
/** Figma's "Copy as SVG": the markup as text. */
const copySvg = async () => {
try {
const out = await selectedSvg();
if (!out) return;
await navigator.clipboard.writeText(out.svg);
context.notifyInfo('Copied as SVG');
} catch {
context.notifyError('Could not copy the SVG');
}
};
const copyText = async (text: string) => {
try {
await navigator.clipboard.writeText(text);
context.notifyInfo('Copied');
} catch {
context.notifyError('Could not copy');
}
};
// ---- keyboard -------------------------------------------------------------
const openStep = (step: 1 | -1) => {
const next = stepPage(viewer.pages, viewer.page(), step);
if (next !== undefined) fireAndForget(viewer.openPage(next), 'fig-viewer');
};
/**
* Figma's opacity keys: a digit sets tens of percent (0 is 100%); a
* second one typed quickly makes it exact (4 then 5 is 45%).
*/
let typedOpacity: { digit: number; at: number; key: string } | undefined;
let opacitySteps = 0;
const typeOpacity = (digit: number) => {
const now = performance.now();
const first = typedOpacity;
if (first && now - first.at < OPACITY_TYPING_MS) {
typedOpacity = undefined;
fireAndForget(
editor.setProps(
{ opacity: (first.digit * 10 + digit) / 100 },
first.key
),
'fig-viewer'
);
return;
}
const key = `opacity-keys-${++opacitySteps}`;
typedOpacity = { digit, at: now, key };
fireAndForget(
editor.setProps({ opacity: digit === 0 ? 1 : digit / 10 }, key),
'fig-viewer'
);
};
/** Figma's place image (⇧⌘K): picked images go in the middle of the view. */
const placeImage = () => {
const input = document.createElement('input');
input.type = 'file';
input.accept = 'image/*';
input.multiple = true;
input.onchange = () => {
const files = [...(input.files ?? [])];
if (files.length === 0) return;
const c = viewer.camera();
const v = viewer.viewport();
const at = { x: c.x + v.w / 2 / c.zoom, y: c.y + v.h / 2 / c.zoom };
fireAndForget(
runEdit(
viewer
.containerAt(at)
.then((parent) => editor.importImages(files, at, parent))
),
'fig-viewer'
);
};
input.click();
};
const run = (action: ViewerAction) =>
match(action)
.with('tool-move', () => viewer.setTool('move'))
.with('tool-hand', () => viewer.setTool('hand'))
.with('zoom-in', () => viewer.zoomStep(1))
.with('zoom-out', () => viewer.zoomStep(-1))
.with('zoom-100', () => viewer.zoom100())
.with('zoom-fit', () => viewer.zoomToFit())
.with('zoom-selection', () => viewer.zoomToSelection())
.with('next-frame', () => viewer.stepFrame(1))
.with('previous-frame', () => viewer.stepFrame(-1))
.with('next-page', () => openStep(1))
.with('previous-page', () => openStep(-1))
.with('select-all', () => fireAndForget(viewer.selectAll(), 'fig-viewer'))
.with('escape', () => {
if (showShortcuts()) setShowShortcuts(false);
else if (viewer.tool() !== 'move' && viewer.tool() !== 'hand')
viewer.setTool('move');
else viewer.escapeSelection();
})
.with('select-parent', () => viewer.selectParent())
.with('select-children', () =>
fireAndForget(viewer.selectChildren(), 'fig-viewer')
)
.with('next-sibling', () =>
fireAndForget(viewer.selectSibling(1), 'fig-viewer')
)
.with('previous-sibling', () =>
fireAndForget(viewer.selectSibling(-1), 'fig-viewer')
)
.with('toggle-ui', () => viewer.setUiHidden((h) => !h))
.with('toggle-outline', () => viewer.setOutlineView((o) => !o))
.with('toggle-rulers', () => viewer.setRulers((r) => !r))
.with('toggle-pixel-grid', () => viewer.setPixelGrid((g) => !g))
.with('toggle-layout-grids', () => aids.setGrids((g) => !g))
.with('toggle-layers', () => {
viewer.setUiHidden(false);
viewer.setLayersOpen((o) => !o);
})
.with('toggle-design', () => {
viewer.setUiHidden(false);
viewer.setDesignOpen((o) => !o);
})
.with('collapse-layers', () => viewer.collapseLayers())
.with('copy-png', () => fireAndForget(copyPng(), 'fig-viewer'))
.with('export', () =>
fireAndForget(handoff.exportSelection(), 'fig-viewer')
)
.with('find', () => {
viewer.setUiHidden(false);
viewer.setLayersOpen(true);
setLeftTab('layers');
queueMicrotask(() => focusSearch?.());
})
.with('show-shortcuts', () => setShowShortcuts((s) => !s))
.with('open-actions', () => {
if (!showActions()) {
setShowActions(true);
return;
}
setShowActions(false);
root.focus({ preventScroll: true });
})
.with('toggle-assets', () => {
viewer.setUiHidden(false);
if (viewer.layersOpen() && leftTab() === 'assets') {
viewer.setLayersOpen(false);
return;
}
viewer.setLayersOpen(true);
setLeftTab('assets');
})
.with('tool-frame', () => viewer.setTool('frame'))
.with('tool-rectangle', () => viewer.setTool('rectangle'))
.with('tool-ellipse', () => viewer.setTool('ellipse'))
.with('tool-text', () => viewer.setTool('text'))
.with('tool-line', () => viewer.setTool('line'))
.with('tool-arrow', () => viewer.setTool('arrow'))
.with('tool-pen', () => viewer.setTool('pen'))
.with('tool-pencil', () => viewer.setTool('pencil'))
.with('place-image', () => placeImage())
.with('undo', () => {
editor.endVectorEdit();
fireAndForget(editor.undo(), 'fig-viewer');
})
.with('redo', () => {
editor.endVectorEdit();
fireAndForget(editor.redo(), 'fig-viewer');
})
.with('delete', () =>
fireAndForget(editor.deleteSelection(), 'fig-viewer')
)
.with('duplicate', () =>
fireAndForget(editor.duplicateSelection(), 'fig-viewer')
)
.with('copy', () => editor.copy())
.with('cut', () => fireAndForget(editor.cut(), 'fig-viewer'))
.with('paste', () => fireAndForget(runEdit(editor.paste()), 'fig-viewer'))
.with('paste-replace', () =>
fireAndForget(runEdit(editor.pasteToReplace()), 'fig-viewer')
)
.with('group', () => fireAndForget(editor.group(), 'fig-viewer'))
.with('ungroup', () => fireAndForget(editor.ungroup(), 'fig-viewer'))
.with('frame-selection', () =>
fireAndForget(editor.group(true), 'fig-viewer')
)
.with('add-auto-layout', () =>
fireAndForget(editor.addAutoLayout(), 'fig-viewer')
)
.with('create-component', () =>
fireAndForget(editor.createComponent(), 'fig-viewer')
)
.with('detach-instance', () =>
fireAndForget(editor.detachInstance(), 'fig-viewer')
)
.with('remove-auto-layout', () =>
fireAndForget(editor.removeAutoLayout(), 'fig-viewer')
)
.with('boolean-union', () =>
fireAndForget(editor.booleanOp('UNION'), 'fig-viewer')
)
.with('boolean-subtract', () =>
fireAndForget(editor.booleanOp('SUBTRACT'), 'fig-viewer')
)
.with('boolean-intersect', () =>
fireAndForget(editor.booleanOp('INTERSECT'), 'fig-viewer')
)
.with('boolean-exclude', () =>
fireAndForget(editor.booleanOp('XOR'), 'fig-viewer')
)
.with('flatten', () => fireAndForget(editor.flatten(), 'fig-viewer'))
.with('bring-forward', () =>
fireAndForget(editor.arrange('forward'), 'fig-viewer')
)
.with('send-backward', () =>
fireAndForget(editor.arrange('backward'), 'fig-viewer')
)
.with('bring-to-front', () =>
fireAndForget(editor.arrange('front'), 'fig-viewer')
)
.with('send-to-back', () =>
fireAndForget(editor.arrange('back'), 'fig-viewer')
)
.with('toggle-visible', () => {
const visible = info()?.visible ?? true;
fireAndForget(editor.setProps({ visible: !visible }), 'fig-viewer');
})
.with('toggle-locked', () => {
fireAndForget(editor.toggleLocked(), 'fig-viewer');
})
.with('flip-horizontal', () =>
fireAndForget(editor.flip(false), 'fig-viewer')
)
.with('flip-vertical', () =>
fireAndForget(editor.flip(true), 'fig-viewer')
)
.with('rename', () => viewer.requestRename())
.with('align-left', () =>
fireAndForget(runEdit(editor.align('left')), 'fig-viewer')
)
.with('align-center', () =>
fireAndForget(runEdit(editor.align('center')), 'fig-viewer')
)
.with('align-right', () =>
fireAndForget(runEdit(editor.align('right')), 'fig-viewer')
)
.with('align-top', () =>
fireAndForget(runEdit(editor.align('top')), 'fig-viewer')
)
.with('align-middle', () =>
fireAndForget(runEdit(editor.align('middle')), 'fig-viewer')
)
.with('align-bottom', () =>
fireAndForget(runEdit(editor.align('bottom')), 'fig-viewer')
)
.with('distribute-horizontal', () =>
fireAndForget(editor.distribute('horizontal'), 'fig-viewer')
)
.with('distribute-vertical', () =>
fireAndForget(editor.distribute('vertical'), 'fig-viewer')
)
.with('swap-fill-stroke', () => {
const i = info();
if (i) fireAndForget(editor.swapFillStroke(i), 'fig-viewer');
})
.with(
'opacity-0',
'opacity-1',
'opacity-2',
'opacity-3',
'opacity-4',
'opacity-5',
'opacity-6',
'opacity-7',
'opacity-8',
'opacity-9',
(a) => typeOpacity(Number(a.slice('opacity-'.length)))
)
.with('nudge-left', () =>
fireAndForget(editor.nudge(-1, 0), 'fig-viewer')
)
.with('nudge-right', () =>
fireAndForget(editor.nudge(1, 0), 'fig-viewer')
)
.with('nudge-up', () => fireAndForget(editor.nudge(0, -1), 'fig-viewer'))
.with('nudge-down', () => fireAndForget(editor.nudge(0, 1), 'fig-viewer'))
.with('nudge-left-10', () =>
fireAndForget(editor.nudge(-10, 0), 'fig-viewer')
)
.with('nudge-right-10', () =>
fireAndForget(editor.nudge(10, 0), 'fig-viewer')
)
.with('nudge-up-10', () =>
fireAndForget(editor.nudge(0, -10), 'fig-viewer')
)
.with('nudge-down-10', () =>
fireAndForget(editor.nudge(0, 10), 'fig-viewer')
)
.exhaustive();
/**
* Enter on a lone text layer types into it, and on a lone shape edits its
* points, as in Figma.
*/
const enterAction = (
action: ViewerAction
): ViewerAction | 'edit-text' | 'edit-vector' => {
const i = info();
if (
action !== 'select-children' ||
!editor.enabled() ||
viewer.selected().length !== 1
)
return action;
if (i?.type === 'TEXT') return 'edit-text';
if (i && VECTOR_EDITABLE.has(i.type)) return 'edit-vector';
return action;
};
/**
* Keys while drawing with the pen or editing points: Enter and Escape
* finish, Delete removes the selected point. Returns whether it was used.
*/
const shapeKey = (e: KeyboardEvent): boolean => {
const finish = e.key === 'Enter' || e.key === 'Escape';
if (editor.penPath()) {
if (!finish) return false;
fireAndForget(runEdit(editor.penFinish(false)), 'fig-viewer');
return true;
}
const edit = editor.vectorEdit();
if (!edit) return false;
if (finish) {
editor.endVectorEdit();
return true;
}
if (
(e.key === 'Delete' || e.key === 'Backspace') &&
edit.selected !== undefined
) {
fireAndForget(
editor.setVectorNetwork(deleteVertex(edit.network, edit.selected)),
'fig-viewer'
);
return true;
}
return false;
};
const [textEditing, setTextEditing] = createSignal<string>();
// ---- other people -------------------------------------------------------
const [pointer, setPointer] = createSignal<Point | null>(null);
const [following, setFollowing] = createSignal<string>();
const peerOverlays = collab
? createPeerOverlays(engine, viewer, collab.peers)
: undefined;
const followed = () => collab?.peers().find((p) => p.peerId === following());
// Presence goes to the sync service (an external system).
createEffect(() => {
if (!collab) return;
const c = viewer.camera();
const v = viewer.viewport();
collab.setPresence({
page: viewer.pages[viewer.page()]?.id ?? '',
selection: viewer.selected().map((s) => s.id),
cursor: pointer(),
editing: textEditing() ?? null,
editor: editor.enabled(),
view:
v.w > 0 ? { x: c.x, y: c.y, w: v.w / c.zoom, h: v.h / c.zoom } : null,
});
});
/** Shows what a followed person sees: their page and view. */
let shownView = '';
const showPeerView = async (peer: FigPeer) => {
const { page, view } = peer.presence;
const key = `${page}|${view?.x}|${view?.y}|${view?.w}|${view?.h}`;
if (key === shownView) return;
shownView = key;
const index = viewer.pages.findIndex((p) => p.id === page);
if (index >= 0 && index !== viewer.page()) await viewer.openPage(index);
if (view) viewer.zoomToRect(view);
};
createEffect(
on(followed, (peer) => {
if (!peer) {
shownView = '';
if (following()) setFollowing(undefined);
return;
}
fireAndForget(showPeerView(peer), 'fig-viewer');
})
);
/** Panning, zooming, or clicking the canvas stops following. */
const stopFollowing = (e: Event) => {
if ((e.target as Element).closest?.('[data-follow-control]')) return;
if (following()) setFollowing(undefined);
};
const contextMenu = createFigContextMenu({
viewer,
engine,
editor,
mac: IS_MAC,
run,
focus: () => root.focus({ preventScroll: true }),
});
/** Nothing to deselect, no tool to leave, no panel to close. */
const escapeIdle = () =>
!showShortcuts() &&
(viewer.tool() === 'move' || viewer.tool() === 'hand') &&
viewer.selected().length === 0;
const onKeyDown = (e: KeyboardEvent) => {
const target = e.target as HTMLElement;
// Presenting takes its own keys.
if (review.presenting()) return;
const mod = IS_MAC ? e.metaKey : e.ctrlKey;
// ⌘P is the actions menu anywhere in the design, never the browser's
// print (Figma's quick actions; Figma's ⌘K is the app's command menu).
if (mod && !e.altKey && !e.shiftKey && e.code === 'KeyP') {
e.preventDefault();
e.stopPropagation();
run('open-actions');
return;
}
if (mod && !e.altKey && !e.shiftKey && e.code === 'KeyK') {
context.suggestActions?.(() => setShowActions(true));
return;
}
if (target.closest('input, textarea, [contenteditable="true"]')) return;
// Menus (portaled, so their events bubble here) handle their own keys.
if (target.closest('[role="menu"]')) return;
// Menus, tabs, and panel dividers use arrows without moving the selection.
if (
!mod &&
target.closest(
'[aria-haspopup="menu"], [aria-haspopup="true"], [role="tab"], [role="separator"]'
) &&
[
'ArrowUp',
'ArrowDown',
'ArrowLeft',
'ArrowRight',
'Home',
'End',
].includes(e.key)
)
return;
// A focused select or button keeps the keys it uses itself.
const control = target.closest('select, button, a[href]');
if (control && controlOwnsKey(control.tagName, e)) return;
if (review.onKey(e)) return;
if (e.key === ' ') {
e.preventDefault();
e.stopPropagation();
setSpaceHeld(true);
return;
}
if (e.key === 'Alt') setAltHeld(true);
if (e.key === 'Meta' || e.key === 'Control') setDeepHeld(true);
if (shapeKey(e)) {
e.preventDefault();
e.stopPropagation();
return;
}
const action = shortcutAction(e, IS_MAC);
if (!action) return;
if (EDIT_ACTIONS.has(action) && !editor.enabled()) return;
// ⌘V goes through the paste event, which carries pasted image files.
if (action === 'paste') return;
// With nothing to act on, the key is the app's (⇧← focuses the split
// to the left, Escape leaves a spotlighted split, ⇧⌘C copies the link).
if (SELECTION_ACTIONS.has(action) && viewer.selected().length === 0) return;
if (action === 'escape' && escapeIdle()) return;
e.preventDefault();
e.stopPropagation();
const resolved = enterAction(action);
if (resolved === 'edit-text') setTextEditing(info()?.id);
else if (resolved === 'edit-vector') {
const id = info()?.id;
if (id) fireAndForget(runEdit(editor.editVector(id)), 'fig-viewer');
} else run(resolved);
};
/**
* Keys pressed in the design reach it before the app's hotkeys (which
* listen on the document while capturing), so where they overlap the
* design's shortcuts win, as in Figma: R, T, O, H, \, ⌘\, ⌘Z and others.
* Keys it does not use go on to the app (⌘K, ⌘S, G, /…).
*/
const handledEarly = new WeakSet<Event>();
onMount(() => {
const onWindowKeyDown = (e: KeyboardEvent) => {
if (!(e.target instanceof Node) || !root.contains(e.target)) return;
handledEarly.add(e);
onKeyDown(e);
};
window.addEventListener('keydown', onWindowKeyDown, true);
onCleanup(() =>
window.removeEventListener('keydown', onWindowKeyDown, true)
);
});
/** Keys from the design's portaled popovers, which bubble here. */
const onPortaledKeyDown = (e: KeyboardEvent) => {
if (!handledEarly.has(e)) onKeyDown(e);
};
const onKeyUp = (e: KeyboardEvent) => {
if (e.key === ' ') setSpaceHeld(false);
if (e.key === 'Alt') setAltHeld(false);
if (e.key === 'Meta' || e.key === 'Control') setDeepHeld(false);
};
// Pasting image files places them in the middle of the view.
const onPaste = (e: ClipboardEvent) => {
const target = e.target as HTMLElement;
if (target.closest?.('input, textarea, [contenteditable="true"]')) return;
const files = [...(e.clipboardData?.files ?? [])].filter((f) =>
f.type.startsWith('image/')
);
if (!editor.enabled()) return;
e.preventDefault();
if (files.length === 0) {
// Layers copied here, in another file, or in Figma.
fireAndForget(
runEdit(
editor.paste(e.clipboardData?.getData('text/html') || undefined)
),
'fig-viewer'
);
return;
}
const c = viewer.camera();
const v = viewer.viewport();
const at = { x: c.x + v.w / 2 / c.zoom, y: c.y + v.h / 2 / c.zoom };
fireAndForget(
runEdit(
viewer
.containerAt(at)
.then((parent) => editor.importImages(files, at, parent))
),
'fig-viewer'
);
};
const releaseModifiers = () => {
setSpaceHeld(false);
setAltHeld(false);
setDeepHeld(false);
};
onMount(() => {
window.addEventListener('blur', releaseModifiers);
onCleanup(() => window.removeEventListener('blur', releaseModifiers));
});
const zoomItems = () => [
{
label: 'Zoom in',
shortcut: IS_MAC ? '⌘+' : 'Ctrl++',
onSelect: () => run('zoom-in'),
},
{
label: 'Zoom out',
shortcut: IS_MAC ? '⌘-' : 'Ctrl+-',
onSelect: () => run('zoom-out'),
},
{
label: 'Zoom to fit',
shortcut: '⇧1',
onSelect: () => run('zoom-fit'),
testId: 'fig-zoom-fit',
},
{
label: 'Zoom to selection',
shortcut: '⇧2',
onSelect: () => run('zoom-selection'),
},
{
label: 'Zoom to 100%',
shortcut: '⇧0',
onSelect: () => run('zoom-100'),
testId: 'fig-zoom-100',
},
'divider' as const,
{
label: 'Pixel grid',
shortcut: "⇧'",
checked: viewer.pixelGrid(),
onSelect: () => run('toggle-pixel-grid'),
},
{
label: 'Layout grids',
shortcut: IS_MAC ? '⌃G' : 'Ctrl+⇧4',
checked: aids.grids(),
onSelect: () => run('toggle-layout-grids'),
testId: 'fig-layout-grids-toggle',
},
{
label: 'Rulers',
shortcut: '⇧R',
checked: viewer.rulers(),
onSelect: () => run('toggle-rulers'),
},
{
label: 'Outline view',
shortcut: IS_MAC ? '⌘Y' : 'Ctrl+Y',
checked: viewer.outlineView(),
onSelect: () => run('toggle-outline'),
testId: 'fig-outline-toggle',
},
{
label: 'Show UI',
shortcut: IS_MAC ? '⌘\\' : 'Ctrl+\\',
checked: !viewer.uiHidden(),
onSelect: () => run('toggle-ui'),
},
];
const showLayers = () => !viewer.uiHidden() && viewer.layersOpen();
const showDesign = () => !viewer.uiHidden() && viewer.designOpen();
return (
<div
ref={root}
tabIndex={0}
class="fig-editor-theme relative flex size-full min-h-0 min-w-0 bg-page outline-none"
data-testid="fig-viewer"
onKeyDown={onPortaledKeyDown}
onKeyUp={onKeyUp}
onPaste={onPaste}
>
<Show when={showLayers()}>
<ResizablePanel
side="left"
label="Pages and layers"
width={leftWidth()}
onResize={setLeftWidth}
onContextMenu={contextMenu.onLayers}
>
<Tabs
class="flex min-h-0 flex-1 flex-col"
value={leftTab()}
onChange={(value) => setLeftTab(value as 'layers' | 'assets')}
>
<div class="flex h-12 shrink-0 items-center gap-1 px-3 text-xs">
<MainMenu
canEdit={editor.enabled()}
hasSelection={viewer.selected().length > 0}
canUndo={editor.canUndo()}
canRedo={editor.canRedo()}
zoomItems={zoomItems()}
onRun={run}
onExportFramesPdf={() =>
fireAndForget(handoff.exportFramesPdf(), 'fig-viewer')
}
/>
<span
class="min-w-0 flex-1 truncate font-semibold"
title={context.fileName()}
>
{context.fileName()}
</span>
<Show when={editor.enabled()}>
<SaveIndicator state={editor.saveState()} />
</Show>
<PanelToggle
side="left"
open
onClick={() => viewer.setLayersOpen(false)}
/>
</div>
<Tabs.List
class="flex h-10 shrink-0 items-center gap-1 border-edge-frame border-b px-3 text-xs"
aria-label="File navigation"
>
<For each={['layers', 'assets'] as const}>
{(t) => (
<Tabs.Trigger
value={t}
class="rounded-md px-2 py-1 font-medium"
classList={{
'bg-hover text-ink': leftTab() === t,
'text-ink-muted': leftTab() !== t,
}}
data-testid={`fig-tab-${t}`}
>
{t === 'layers' ? 'File' : 'Assets'}
</Tabs.Trigger>
)}
</For>
</Tabs.List>
<Tabs.Content
value="assets"
class="flex min-h-0 flex-1 flex-col outline-none"
>
<AssetsPanel
viewer={viewer}
engine={engine}
editor={editor}
libraries={libraries}
fileName={context.fileName()}
/>
</Tabs.Content>
<Tabs.Content
value="layers"
class="flex min-h-0 flex-1 flex-col outline-none"
>
<LayersPanel
viewer={viewer}
engine={engine}
editor={editor}
focusSearchRef={(focus) => {
focusSearch = focus;
}}
/>
</Tabs.Content>
</Tabs>
</ResizablePanel>
</Show>
<div
class="relative min-w-0 flex-1"
onPointerDown={stopFollowing}
onWheel={stopFollowing}
onContextMenu={contextMenu.onCanvas}
>
<ViewerCanvas
viewer={viewer}
engine={engine}
spaceHeld={spaceHeld}
altHeld={altHeld}
deepHeld={deepHeld}
editor={editor}
info={info}
onEditText={(id) => setTextEditing(id)}
onInvalidator={(fn) => {
invalidate = fn;
}}
peers={peerOverlays}
onPointer={collab ? setPointer : undefined}
onMove={onMove}
aids={aids}
devMode={devMode}
drop={
libraries && {
type: LIBRARY_ASSET_MIME,
onDrop: (data, at, parent) =>
fireAndForget(
libraries.dropAsset(data, at, parent),
'fig-viewer'
),
}
}
>
<Show when={textEditing()}>
{(id) => (
<TextEditor
id={id()}
viewer={viewer}
editor={editor}
engine={engine}
fonts={fonts}
onDone={() => {
setTextEditing(undefined);
root.focus({ preventScroll: true });
}}
/>
)}
</Show>
<Show
when={
showDesign() &&
review.panelTab() === 'prototype' &&
!review.comments?.active() &&
review.prototype()
}
>
{(info) => (
<PrototypeNoodles
info={info()}
camera={viewer.camera()}
selected={viewer.selected().map((s) => s.id)}
/>
)}
</Show>
<Show when={review.comments?.active() && review.comments}>
{(c) => (
<CommentPins
comments={c()}
camera={viewer.camera()}
viewport={viewer.viewport()}
onDismiss={() => root.focus({ preventScroll: true })}
/>
)}
</Show>
<Show when={libraries}>
{(l) => <LibraryUpdates libraries={l()} />}
</Show>
<Show when={editor.enabled() && fonts.missing().length > 0}>
<MissingFonts
fonts={fonts.missing()}
canUseLocal={fonts.canUseLocalFonts()}
onUseLocal={() =>
fireAndForget(fonts.useLocalFonts(), 'fig-viewer')
}
/>
</Show>
<Show when={viewer.loadingPage()}>
<div class="pointer-events-none absolute inset-0 flex items-center justify-center text-ink-muted text-sm">
Loading page…
</div>
</Show>
<Show when={!viewer.uiHidden() && !showLayers()}>
<div class="absolute top-2 left-3 z-10 rounded-lg border border-edge-muted bg-panel p-1">
<PanelToggle
side="left"
open={false}
onClick={() => viewer.setLayersOpen(true)}
/>
</div>
</Show>
<Show when={!viewer.uiHidden() && !showDesign()}>
<div
class="absolute top-2 right-3 z-10 flex items-center gap-1 rounded-lg border border-edge-muted bg-panel px-1"
onPointerDown={(e) => e.stopPropagation()}
>
<PresentButton
mac={IS_MAC}
onPresent={() => fireAndForget(review.present(), 'fig-viewer')}
/>
<ViewerZoom
label={zoomLabel(viewer.camera().zoom)}
items={zoomItems()}
/>
<Show when={!showDesign()}>
<PanelToggle
side="right"
open={false}
onClick={() => viewer.setDesignOpen(true)}
/>
</Show>
</div>
</Show>
<Show when={collab}>
{(c) => (
<div
data-follow-control
onPointerDown={(e) => e.stopPropagation()}
>
<PeerAvatars
peers={c().peers()}
following={following()}
onFollow={setFollowing}
status={c().status()}
/>
</div>
)}
</Show>
<Show when={followed()}>
{(peer) => (
<div
data-follow-control
onPointerDown={(e) => e.stopPropagation()}
>
<FollowFrame
peer={peer()}
onStop={() => setFollowing(undefined)}
/>
</div>
)}
</Show>
<Show when={showShortcuts()}>
<ShortcutsDialog
mac={IS_MAC}
onClose={() => setShowShortcuts(false)}
/>
</Show>
<Show when={showActions()}>
<ActionsPalette
mac={IS_MAC}
available={(action) =>
!EDIT_ACTIONS.has(action) || editor.enabled()
}
onRun={run}
onClose={(refocus) => {
setShowActions(false);
// Back to the canvas, so its shortcuts work again.
if (refocus) root.focus({ preventScroll: true });
}}
/>
</Show>
<FigContextMenu
at={contextMenu.menu()?.at}
entries={contextMenu.menu()?.entries ?? []}
mac={IS_MAC}
onSelect={contextMenu.choose}
onClose={contextMenu.close}
/>
</ViewerCanvas>
</div>
<Show when={showDesign() && review.comments?.active() && review.comments}>
{(c) => (
<ResizablePanel
side="right"
label="Comments"
width={rightWidth()}
onResize={setRightWidth}
>
<CommentsPanel
comments={c()}
headerActions={
<>
<PresentButton
mac={IS_MAC}
onPresent={() =>
fireAndForget(review.present(), 'fig-viewer')
}
/>
<PanelToggle
side="right"
open
onClick={() => viewer.setDesignOpen(false)}
/>
</>
}
zoom={
<ViewerZoom
label={zoomLabel(viewer.camera().zoom)}
items={zoomItems()}
/>
}
pageName={(id) => viewer.pages.find((p) => p.id === id)?.name}
/>
</ResizablePanel>
)}
</Show>
<Show when={showDesign() && !review.comments?.active()}>
<ResizablePanel
side="right"
label="Properties"
width={rightWidth()}
onResize={setRightWidth}
>
<DesignPanel
tab={review.panelTab()}
headerActions={
<>
<PresentButton
mac={IS_MAC}
onPresent={() =>
fireAndForget(review.present(), 'fig-viewer')
}
/>
<PanelToggle
side="right"
open
onClick={() => viewer.setDesignOpen(false)}
/>
</>
}
zoom={
<ViewerZoom
label={zoomLabel(viewer.camera().zoom)}
items={zoomItems()}
/>
}
info={panel().info}
fontFamilies={[
...new Set([
'Inter',
...fonts.documentFonts().map((f) => f.family),
]),
]}
type={{
mixed: panel().mixed,
googleFamilies: fonts.families().map((f) => f.family),
weights: shownFamily()
? fonts.weightsOf(shownFamily() ?? '')
: undefined,
preview: fonts.preview,
onFontsOpen: () =>
fireAndForget(fonts.loadCatalog(), 'fig-viewer'),
}}
onAlign={
editor.enabled()
? (how) =>
fireAndForget(runEdit(editor.align(how)), 'fig-viewer')
: undefined
}
onFlip={
editor.enabled()
? (axis) =>
run(
axis === 'horizontal'
? 'flip-horizontal'
: 'flip-vertical'
)
: undefined
}
onPatch={editor.enabled() ? patchSelection : undefined}
onPageColor={editor.enabled() ? setPageColor : undefined}
swatches={swatches()}
mixed={mixed()}
onPickerOpen={() => fireAndForget(loadSwatches(), 'fig-viewer')}
onAddImage={editor.enabled() ? addImage : undefined}
onAddAutoLayout={
editor.enabled()
? () => fireAndForget(editor.addAutoLayout(), 'fig-viewer')
: undefined
}
selectionCount={viewer.selected().length}
page={viewer.pages[viewer.page()]}
exportSection={
<Show when={info()?.id} keyed>
{(id) => (
<ExportSection
name={info()?.name ?? ''}
count={1}
settings={info()?.exportSettings ?? []}
onChange={
editor.enabled() && !id.startsWith('I')
? handoff.setExports
: undefined
}
onExport={(settings) =>
fireAndForget(
handoff.exportSelection(settings),
'fig-viewer'
)
}
preview={handoff.preview}
onCopyPng={() => fireAndForget(copyPng(), 'fig-viewer')}
onCopySvg={() => fireAndForget(copySvg(), 'fig-viewer')}
/>
)}
</Show>
}
layoutGrids={
<Show
when={
info() &&
['FRAME', 'SYMBOL', 'INSTANCE'].includes(
info()?.type ?? ''
) &&
(editor.enabled() || (info()?.layoutGrids.length ?? 0) > 0)
}
>
<LayoutGridSection
grids={info()?.layoutGrids ?? []}
onChange={
editor.enabled() && !info()?.id.startsWith('I')
? handoff.setGrids
: undefined
}
swatches={swatches()}
onPickerOpen={() =>
fireAndForget(loadSwatches(), 'fig-viewer')
}
/>
</Show>
}
code={
<Show when={panel().info}>
{(i) => (
<DevInspect
info={i()}
design={designSystem.info()}
assets={handoff.assets()}
onCopy={(text) =>
fireAndForget(copyText(text), 'fig-viewer')
}
onDownload={(id, s) =>
fireAndForget(handoff.downloadAsset(id, s), 'fig-viewer')
}
/>
)}
</Show>
}
onBoolean={
editor.enabled()
? (op) => fireAndForget(editor.booleanOp(op), 'fig-viewer')
: undefined
}
onFlatten={() => fireAndForget(editor.flatten(), 'fig-viewer')}
onCreateComponent={
editor.enabled() &&
!viewer.selected().some((node) => node.id.startsWith('I'))
? () => fireAndForget(editor.createComponent(), 'fig-viewer')
: undefined
}
onCopyText={(text) => fireAndForget(copyText(text), 'fig-viewer')}
onTabChange={review.setPanelTab}
prototype={
<PrototypePanel
info={review.prototype()}
selected={
viewer.selected().length === 1 && info()
? { id: info()?.id ?? '', name: info()?.name ?? '' }
: undefined
}
onInteractions={
editor.enabled()
? (id, index, edited) =>
fireAndForget(
review.setInteraction(id, index, edited),
'fig-viewer'
)
: undefined
}
onFlowStart={editor.enabled() ? review.setFlowStart : undefined}
onPresent={(frame) =>
fireAndForget(review.present(frame), 'fig-viewer')
}
/>
}
designSections={
<DesignSystemSections
ds={designSystem}
selected={viewer.selected()[0]?.id}
/>
}
styleControl={styleControl}
pageExtra={
<LocalStylesView ds={designSystem} swatches={swatches()} />
}
/>
</ResizablePanel>
</Show>
<Show when={!viewer.uiHidden()}>
<ViewerToolbar
tool={review.comments?.active() ? undefined : viewer.tool()}
onTool={(tool) => {
review.comments?.setActive(false);
if (editor.penPath())
fireAndForget(runEdit(editor.penFinish()), 'fig-viewer');
viewer.setTool(tool);
}}
editable={editor.enabled()}
onActions={() => setShowActions(true)}
devMode={review.panelTab() === 'code'}
onDevMode={() => {
viewer.setDesignOpen(true);
review.comments?.setActive(false);
review.setPanelTab((tab) => (tab === 'code' ? 'design' : 'code'));
}}
review={
<CommentButton
comments={
review.comments && {
active: review.comments.active(),
unread: review.comments.unreadCount(),
onToggle: review.toggleComments,
}
}
/>
}
/>
</Show>
<Show when={review.presenting()}>
{(p) => (
<PresentMode
engine={engine}
page={p().page}
info={p().info}
start={p().start}
onExit={() => {
review.stopPresenting();
root.focus({ preventScroll: true });
}}
onCopyLink={review.copyFrameLink}
/>
)}
</Show>
</div>
);
}