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 left panel: the file's pages and the current page's layer tree,
* loaded lazily as rows expand, with search (⌘F).
*/
import { IS_MAC } from '@core/constant/isMac';
import type { FigEngine } from '@core/fig-engine/client';
import type { LayerRow, SearchHit } from '@core/fig-engine/types';
import { fireAndForget } from '@core/util/fireAndForget';
import CaretDown from '@icon/system/regular/caret-down.svg';
import CaretRight from '@icon/system/regular/caret-right.svg';
import Eye from '@icon/system/regular/eye.svg';
import EyeSlash from '@icon/system/regular/eye-slash.svg';
import LockSimple from '@icon/system/regular/lock-simple.svg';
import LockSimpleOpen from '@icon/system/regular/lock-simple-open.svg';
import MagnifyingGlass from '@icon/system/regular/magnifying-glass.svg';
import Plus from '@icon/system/regular/plus.svg';
import Trash from '@icon/system/regular/trash.svg';
import XIcon from '@icon/system/regular/x.svg';
import {
createEffect,
createMemo,
createSignal,
For,
on,
Show,
} from 'solid-js';
import { VList, type VListHandle } from 'virtua/solid';
import { isComponentType, LayerIcon } from '../components/layer-icon';
import { rowClick, treeMove } from '../core/layer-tree';
import { isPageDivider } from '../core/pages';
import { isCommitKey } from '../core/shortcuts';
import type { FigEditor } from '../primitives/create-fig-editor';
import type { FigViewer } from '../primitives/create-fig-viewer';
const ROOT = '';
const ROW_HEIGHT = 32;
interface FlatRow {
row: LayerRow;
depth: number;
expanded: boolean;
/** Inside a selected layer (Figma tints these rows). */
inSelection: boolean;
/** Parent layer id (the page's id for top-level rows). */
parent: string;
/** Index among its siblings in the engine's order (bottom first). */
index: number;
}
/** Where a dragged row would land relative to the row under it. */
type DropZone = 'above' | 'below' | 'inside';
export function LayersPanel(props: {
viewer: FigViewer;
engine: FigEngine;
/** Where ⌘F focuses. */
focusSearchRef?: (focus: () => void) => void;
/** Renaming, visibility, locking, and reordering when editable. */
editor?: FigEditor;
}) {
const viewer = props.viewer;
const [children, setChildren] = createSignal(new Map<string, LayerRow[]>());
const [expanded, setExpanded] = createSignal(new Set<string>());
const [query, setQuery] = createSignal('');
const [searchOpen, setSearchOpen] = createSignal(false);
let searchInput: HTMLInputElement | undefined;
let searchButton: HTMLButtonElement | undefined;
const focusSearch = () => {
setSearchOpen(true);
queueMicrotask(() => searchInput?.focus());
};
props.focusSearchRef?.(focusSearch);
const [results, setResults] = createSignal<SearchHit[]>([]);
const [pagesOpen, setPagesOpen] = createSignal(true);
let list: VListHandle | undefined;
const loading = new Set<string>();
const load = async (parent: string) => {
if (loading.has(parent) || children().has(parent)) return;
loading.add(parent);
const page = viewer.page();
try {
const rows = await props.engine.layers(page, parent || undefined);
if (page !== viewer.page()) return;
setChildren((m) => new Map(m).set(parent, rows));
} finally {
loading.delete(parent);
}
};
// A new page starts with a fresh, collapsed tree.
createEffect(
on(viewer.page, () => {
setChildren(new Map());
setExpanded(new Set<string>());
fireAndForget(load(ROOT), 'fig-layers-panel');
})
);
// After edits, every loaded level reloads in place (expansion kept); a
// drag's steps only move layers, so once it pauses is enough.
createEffect(
on(
viewer.editsSettled,
async () => {
const page = viewer.page();
const parents = [...children().keys()];
const fresh = await Promise.all(
parents.map((p) =>
props.engine.layers(page, p || undefined).catch(() => [])
)
);
if (page !== viewer.page()) return;
const next = new Map<string, LayerRow[]>();
parents.forEach((p, i) => next.set(p, fresh[i]));
setChildren(next);
},
{ defer: true }
)
);
createEffect(
on(viewer.collapseSignal, () => setExpanded(new Set<string>()), {
defer: true,
})
);
const selectedIds = createMemo(
() => new Set(viewer.selected().map((s) => s.id))
);
const rows = createMemo<FlatRow[]>(() => {
const out: FlatRow[] = [];
const map = children();
const open = expanded();
const selected = selectedIds();
const pageId = viewer.pages[viewer.page()]?.id ?? '';
const walk = (parent: string, depth: number, inSelection: boolean) => {
const siblings = map.get(parent) ?? [];
siblings.forEach((row, k) => {
const isOpen = open.has(row.id) && row.childCount > 0;
out.push({
row,
depth,
expanded: isOpen,
inSelection,
parent: parent || pageId,
index: siblings.length - 1 - k,
});
if (isOpen)
walk(row.id, depth + 1, inSelection || selected.has(row.id));
});
};
walk(ROOT, 0, false);
return out;
});
const toggle = (row: LayerRow) => {
const next = new Set(expanded());
if (next.has(row.id)) next.delete(row.id);
else {
next.add(row.id);
fireAndForget(load(row.id), 'fig-layers-panel');
}
setExpanded(next);
};
// Reveal the selection: expand its ancestors and scroll to it.
createEffect(
on(
viewer.revealSignal,
async () => {
const first = viewer.selected()[0];
if (!first) return;
const chain = await props.engine.ancestry(viewer.page(), first.id);
const next = new Set(expanded());
for (const r of chain.slice(0, -1)) {
next.add(r.id);
await load(r.id);
}
setExpanded(next);
queueMicrotask(() => {
const at = rows().findIndex((r) => r.row.id === first.id);
if (at >= 0) list?.scrollToIndex(at, { align: 'nearest' });
});
},
{ defer: true }
)
);
// ---- editing ---------------------------------------------------------
const [renaming, setRenaming] = createSignal<string>();
const [renamingPage, setRenamingPage] = createSignal<string>();
const renamePage = (id: string, old: string, name: string) => {
setRenamingPage(undefined);
const trimmed = name.trim();
if (!trimmed || trimmed === old) return;
fireAndForget(
props.editor?.apply([{ op: 'set', ids: [id], props: { name: trimmed } }]),
'fig-layers-panel'
);
};
const addPage = async () => {
const result = await props.editor?.apply([
{
op: 'create',
parent: props.engine.summary.rootId,
node: { type: 'CANVAS', x: 0, y: 0, width: 0, height: 0 },
},
]);
const id = result?.created[0];
if (!id) return;
const index = viewer.pages.findIndex((p) => p.id === id);
if (index >= 0) {
await viewer.openPage(index);
setRenamingPage(id);
}
};
const editable = (row: LayerRow) =>
!!props.editor?.enabled() && !row.id.startsWith('I');
const rename = (row: LayerRow, name: string) => {
setRenaming(undefined);
const trimmed = name.trim();
if (!trimmed || trimmed === row.name) return;
fireAndForget(
props.editor?.apply([
{ op: 'set', ids: [row.id], props: { name: trimmed } },
]),
'fig-layers-panel'
);
};
createEffect(
on(
viewer.renameSignal,
() => {
const first = viewer.selected()[0];
if (first && props.editor?.enabled() && !first.id.startsWith('I'))
setRenaming(first.id);
},
{ defer: true }
)
);
const toggleFlag = (row: LayerRow, flag: 'visible' | 'locked') => {
if (flag === 'locked') {
fireAndForget(props.editor?.toggleLocked([row.id]), 'fig-layers-panel');
return;
}
fireAndForget(
props.editor?.apply([
{
op: 'set',
ids: [row.id],
props: { visible: !row.visible },
},
]),
'fig-layers-panel'
);
};
const [dragging, setDragging] = createSignal<string[]>();
const [drop, setDrop] = createSignal<{ id: string; zone: DropZone }>();
const zoneFor = (e: DragEvent, item: FlatRow): DropZone => {
const r = (e.currentTarget as HTMLElement).getBoundingClientRect();
const t = (e.clientY - r.top) / r.height;
const container = ['FRAME', 'GROUP', 'SECTION', 'SYMBOL'].includes(
item.row.type
);
if (container && t > 0.3 && t < 0.7) return 'inside';
return t < 0.5 ? 'above' : 'below';
};
const onDrop = (item: FlatRow) => {
const ids = dragging();
const target = drop();
setDragging(undefined);
setDrop(undefined);
if (!ids || !target || ids.includes(item.row.id)) return;
// The list shows the top-most layer first; "above" is in front.
const op =
target.zone === 'inside'
? { parent: item.row.id, index: item.row.childCount }
: {
parent: item.parent,
index: target.zone === 'above' ? item.index + 1 : item.index,
};
fireAndForget(
props.editor?.apply([{ op: 'reorder', ids, ...op }]),
'fig-layers-panel'
);
};
let searchRun = 0;
const search = async (q: string) => {
setQuery(q);
const run = ++searchRun;
if (!q.trim()) {
setResults([]);
return;
}
const hits = await props.engine.search(viewer.page(), q.trim(), 300);
if (run === searchRun) setResults(hits);
};
// Shift-click selects the rows between the last clicked one and this
// one; ⌘/Ctrl-click toggles a row (Figma's layer list).
let anchor: string | undefined;
let tree: HTMLDivElement | undefined;
const onRowClick = (row: LayerRow, e: MouseEvent) => {
// The range starts at the last clicked row, or at the selection made
// elsewhere (the canvas, search).
const selected = viewer.selected();
const from = selected.some((s) => s.id === anchor)
? anchor
: selected.at(-1)?.id;
const click = rowClick(
rows().map((r) => r.row.id),
row.id,
from,
{ shift: e.shiftKey, toggle: IS_MAC ? e.metaKey : e.ctrlKey }
);
if (!e.shiftKey) anchor = row.id;
tree?.focus({ preventScroll: true });
if (click.kind === 'select') {
selectRows(click.ids);
return;
}
const current = viewer.selected();
if (current.some((s) => s.id === click.id))
viewer.select(current.filter((s) => s.id !== click.id));
else selectRows([...current.map((s) => s.id), click.id]);
};
/** Selects rows shown in the tree at once (their parents are known). */
const selectRows = (ids: string[]) => {
const byId = new Map(rows().map((r) => [r.row.id, r]));
const known = viewer.selected();
viewer.select(
ids.flatMap((id) => {
const r = byId.get(id);
if (r) return [{ id, parent: r.depth > 0 ? r.parent : null }];
const s = known.find((k) => k.id === id);
return s ? [s] : [];
})
);
};
/**
* Read-only, arrow keys move through the rows shown, and expand or
* collapse. Editing, they nudge the selection, as in Figma, whose layers
* list leaves the arrows to the canvas (Tab, Enter, and ⇧Enter move
* through the layers there).
*/
const onTreeKey = (e: KeyboardEvent) => {
if (
props.editor?.enabled() ||
e.metaKey ||
e.ctrlKey ||
e.altKey ||
(e.key !== 'ArrowUp' &&
e.key !== 'ArrowDown' &&
e.key !== 'ArrowLeft' &&
e.key !== 'ArrowRight')
)
return;
e.preventDefault();
e.stopPropagation();
const shown = rows();
const move = treeMove(
shown.map((r) => ({
id: r.row.id,
parent: r.depth > 0 ? r.parent : undefined,
hasChildren: r.row.childCount > 0,
expanded: r.expanded,
})),
viewer.selected().at(-1)?.id,
e.key
);
if (!move) return;
if (move.kind === 'select') {
anchor = move.id;
selectRows([move.id]);
return;
}
const row = shown.find((r) => r.row.id === move.id)?.row;
if (row) toggle(row);
};
return (
<div
class="flex size-full min-h-0 flex-col text-ink text-xs"
data-testid="fig-layers-panel"
>
<Show when={searchOpen()}>
<div class="flex h-10 shrink-0 items-center gap-1.5 border-edge-frame border-b px-3">
<MagnifyingGlass class="size-3.5 shrink-0 text-ink-muted" />
<input
ref={searchInput}
type="search"
placeholder="Find layers"
aria-label="Find layers"
data-testid="fig-layer-search"
class="h-7 min-w-0 flex-1 bg-transparent text-ink outline-none placeholder:text-ink-placeholder"
value={query()}
onInput={(e) =>
fireAndForget(search(e.currentTarget.value), 'fig-layers-panel')
}
onKeyDown={(e) => {
e.stopPropagation();
if (e.key === 'Escape') {
fireAndForget(search(''), 'fig-layers-panel');
setSearchOpen(false);
searchButton?.focus();
}
}}
/>
<button
type="button"
aria-label="Close search"
class="rounded p-0.5 text-ink-muted hover:text-ink"
onClick={() => {
fireAndForget(search(''), 'fig-layers-panel');
setSearchOpen(false);
searchButton?.focus();
}}
>
<XIcon class="size-3" />
</button>
</div>
</Show>
<Show when={!query()}>
<div class="shrink-0 border-edge-frame border-b px-2 pt-2 pb-3">
<div class="flex h-8 items-center gap-1 px-1">
<button
type="button"
class="flex h-7 min-w-0 flex-1 items-center gap-1 font-semibold"
aria-expanded={pagesOpen()}
onClick={() => setPagesOpen((o) => !o)}
>
<Show when={pagesOpen()} fallback={<CaretRight class="size-3" />}>
<CaretDown class="size-3" />
</Show>
<span class="flex-1 text-left">Pages</span>
</button>
<button
ref={searchButton}
type="button"
aria-label="Find layers"
title="Find layers · ⌘F / Ctrl+F"
data-testid="fig-search-toggle"
class="flex size-6 items-center justify-center rounded text-ink-muted hover:bg-hover hover:text-ink"
onClick={focusSearch}
>
<MagnifyingGlass class="size-3.5" />
</button>
<Show when={props.editor?.enabled()}>
<button
type="button"
aria-label="Add page"
data-testid="fig-page-add"
class="flex size-6 items-center justify-center rounded text-ink-muted hover:bg-hover hover:text-ink"
onClick={() => fireAndForget(addPage(), 'fig-layers-panel')}
>
<Plus class="size-3.5" />
</button>
</Show>
</div>
<Show when={pagesOpen()}>
<div class="max-h-48 overflow-y-auto">
<For each={viewer.pages}>
{(p) => (
<Show
when={!isPageDivider(p.name)}
fallback={
<div class="flex h-3 items-center px-6" role="separator">
<div class="h-px w-full bg-edge-frame" />
</div>
}
>
<Show
when={renamingPage() === p.id}
fallback={
<div
class="group flex h-8 w-full items-center rounded-md pr-2 pl-6 hover:bg-hover"
classList={{
'font-medium bg-hover': p.index === viewer.page(),
}}
>
<button
type="button"
data-testid="fig-page"
class="min-w-0 flex-1 truncate text-left"
onClick={() =>
fireAndForget(
viewer.openPage(p.index),
'fig-layers-panel'
)
}
onDblClick={() => {
if (props.editor?.enabled())
setRenamingPage(p.id);
}}
>
{p.name}
</button>
<Show
when={
props.editor?.enabled() && viewer.pages.length > 1
}
>
<button
type="button"
aria-label={`Delete ${p.name}`}
data-testid="fig-page-delete"
class="invisible rounded p-0.5 text-ink-muted hover:text-ink group-hover:visible"
onClick={() =>
fireAndForget(
props.editor?.apply([
{ op: 'delete', ids: [p.id] },
]),
'fig-layers-panel'
)
}
>
<Trash class="size-3" />
</button>
</Show>
</div>
}
>
<input
ref={(el) => queueMicrotask(() => el.select())}
class="mx-4 h-6 w-[calc(100%-2rem)] rounded-sm bg-input px-1 text-ink outline outline-1 outline-accent"
data-testid="fig-page-rename"
value={p.name}
onBlur={(e) =>
renamePage(p.id, p.name, e.currentTarget.value)
}
onKeyDown={(e) => {
e.stopPropagation();
if (isCommitKey(e)) e.currentTarget.blur();
if (e.key === 'Escape') setRenamingPage(undefined);
}}
/>
</Show>
</Show>
)}
</For>
</div>
</Show>
</div>
</Show>
<div
class="flex h-10 shrink-0 items-center px-3 font-semibold"
data-testid="fig-layers-heading"
>
{query() ? 'Search results' : 'Layers'}
</div>
<div
ref={tree}
// Takes the keys after a row is clicked (see `onTreeKey`).
tabIndex={-1}
aria-label="Layers"
data-testid="fig-layer-tree"
class="relative min-h-0 flex-1 outline-none"
onKeyDown={onTreeKey}
>
<Show
when={!query()}
fallback={
<div class="h-full overflow-y-auto py-1">
<Show
when={results().length > 0}
fallback={
<div class="px-3 py-2 text-ink-muted">No matching layers</div>
}
>
<For each={results()}>
{(hit) => (
<button
type="button"
data-testid="fig-search-hit"
class="flex w-full items-start gap-2 px-3 py-1.5 text-left hover:bg-hover"
classList={{ 'bg-selected': selectedIds().has(hit.id) }}
onClick={() => viewer.revealLayer(hit.id)}
>
<LayerIcon
type={hit.type}
class="mt-0.5 size-3.5 shrink-0"
/>
<span class="min-w-0">
<span class="block truncate">{hit.name}</span>
<Show when={hit.text && hit.text !== hit.name}>
<span class="block truncate text-ink-muted">
{hit.text}
</span>
</Show>
</span>
</button>
)}
</For>
</Show>
</div>
}
>
<VList
ref={(h) => {
list = h;
}}
data={rows()}
itemSize={ROW_HEIGHT}
class="h-full"
style={{ height: '100%', width: '100%' }}
>
{(item) => (
<div
role="treeitem"
aria-selected={selectedIds().has(item.row.id)}
aria-expanded={
item.row.childCount > 0 ? item.expanded : undefined
}
data-testid="fig-layer-row"
data-layer-id={item.row.id}
class="group relative flex items-center gap-1 pr-2"
classList={{
'bg-accent/20': selectedIds().has(item.row.id),
'bg-accent/5':
!selectedIds().has(item.row.id) && item.inSelection,
'hover:outline hover:outline-1 hover:-outline-offset-1 hover:outline-accent':
!selectedIds().has(item.row.id),
'text-ink-muted': !item.row.visible,
'text-purple':
isComponentType(item.row.type) || item.row.inInstance,
}}
style={{
height: `${ROW_HEIGHT}px`,
'padding-left': `${12 + item.depth * 16}px`,
}}
draggable={editable(item.row) && renaming() !== item.row.id}
onDragStart={(e) => {
const ids = selectedIds().has(item.row.id)
? [...selectedIds()].filter((id) => !id.startsWith('I'))
: [item.row.id];
setDragging(ids);
e.dataTransfer?.setData('text/plain', ids.join(','));
if (e.dataTransfer) e.dataTransfer.effectAllowed = 'move';
}}
onDragOver={(e) => {
if (!dragging()) return;
e.preventDefault();
setDrop({ id: item.row.id, zone: zoneFor(e, item) });
}}
onDragLeave={() => {
if (drop()?.id === item.row.id) setDrop(undefined);
}}
onDrop={(e) => {
e.preventDefault();
onDrop(item);
}}
onDragEnd={() => {
setDragging(undefined);
setDrop(undefined);
}}
onPointerEnter={() => viewer.hoverLayer(item.row)}
onPointerLeave={() => viewer.hoverLayer(undefined)}
onClick={(e) => onRowClick(item.row, e)}
onDblClick={() => {
if (editable(item.row)) setRenaming(item.row.id);
else viewer.zoomToSelection();
}}
>
<Show when={drop()?.id === item.row.id}>
<div
class="pointer-events-none absolute right-1 left-1 border-accent"
classList={{
'top-0 border-t-2': drop()?.zone === 'above',
'bottom-0 border-b-2': drop()?.zone === 'below',
'inset-y-0 rounded border-2': drop()?.zone === 'inside',
}}
/>
</Show>
<button
type="button"
tabIndex={-1}
aria-label={item.expanded ? 'Collapse' : 'Expand'}
class="flex size-4 shrink-0 items-center justify-center text-ink-muted"
classList={{ invisible: item.row.childCount === 0 }}
onClick={(e) => {
e.stopPropagation();
toggle(item.row);
}}
>
<Show
when={item.expanded}
fallback={<CaretRight class="size-2.5" />}
>
<CaretDown class="size-2.5" />
</Show>
</button>
<LayerIcon type={item.row.type} />
<Show
when={renaming() === item.row.id}
fallback={
<span
class="min-w-0 flex-1 truncate"
classList={{ italic: item.row.isMask }}
>
{item.row.name}
</span>
}
>
<input
ref={(el) => queueMicrotask(() => el.select())}
class="min-w-0 flex-1 rounded-sm bg-input px-1 text-ink outline outline-1 outline-accent"
data-testid="fig-layer-rename"
value={item.row.name}
onClick={(e) => e.stopPropagation()}
onBlur={(e) => rename(item.row, e.currentTarget.value)}
onKeyDown={(e) => {
e.stopPropagation();
if (isCommitKey(e)) e.currentTarget.blur();
if (e.key === 'Escape') setRenaming(undefined);
}}
/>
</Show>
<Show
when={editable(item.row)}
fallback={
<>
<Show when={item.row.locked}>
<LockSimple class="size-3 shrink-0 text-ink-muted" />
</Show>
<Show when={!item.row.visible}>
<EyeSlash class="size-3 shrink-0 text-ink-muted" />
</Show>
</>
}
>
<button
type="button"
tabIndex={-1}
aria-label={item.row.locked ? 'Unlock' : 'Lock'}
class="shrink-0 rounded p-0.5 text-ink-muted hover:text-ink"
classList={{
'invisible group-hover:visible': !item.row.locked,
}}
onClick={(e) => {
e.stopPropagation();
toggleFlag(item.row, 'locked');
}}
>
<Show
when={item.row.locked}
fallback={<LockSimpleOpen class="size-3" />}
>
<LockSimple class="size-3" />
</Show>
</button>
<button
type="button"
tabIndex={-1}
aria-label={item.row.visible ? 'Hide' : 'Show'}
data-testid="fig-layer-visibility"
class="shrink-0 rounded p-0.5 text-ink-muted hover:text-ink"
classList={{
'invisible group-hover:visible': item.row.visible,
}}
onClick={(e) => {
e.stopPropagation();
toggleFlag(item.row, 'visible');
}}
>
<Show
when={item.row.visible}
fallback={<EyeSlash class="size-3" />}
>
<Eye class="size-3" />
</Show>
</button>
</Show>
</div>
)}
</VList>
</Show>
</div>
</div>
);
}