AI-native design editor. Open-source Figma alternative.
<script setup lang="ts">
import { useScroll } from '@vueuse/core'
import {
TreeItem,
TreeVirtualizer,
ContextMenuRoot,
ContextMenuTrigger,
ContextMenuPortal
} from 'reka-ui'
import { tv } from 'tailwind-variants'
import { computed, nextTick, useAttrs, useTemplateRef, watch } from 'vue'
import { useInlineRename } from '@open-pencil/vue/editor/inline-rename'
import {
LayerTreeRoot,
LayerTreeItem,
stickyTopLevelRow,
type LayerDragInstruction,
type LayerNode,
type LayerRow,
type LayerSelectionMode,
type LayerTreeVirtualizer
} from '@open-pencil/vue/primitives/LayerTree'
import { useEditorStore } from '@/app/editor/active-store'
import { layerIssueMarks } from '@/app/editor/design-check/layers'
import { appPreferences } from '@/app/settings/preferences/store'
import layerTreeTheme from '@/theme/layer-tree'
import CanvasMenu from '../canvas/CanvasMenu.vue'
import { useLayerTreeGeometry } from './geometry'
import LayerTreeNodeRow from './LayerTreeNodeRow.vue'
import LayerTreeRenameRow from './LayerTreeRenameRow.vue'
import LayerTreeStickyRow from './LayerTreeStickyRow.vue'
import { provideLayerTreeUI } from './ui'
import type { LayerTreeUI } from './ui'
interface LayerTreeRootActions {
select: (id: string, selection: boolean | LayerSelectionMode) => void
toggleExpand: (id: string) => void
setFocused: (focused: boolean) => void
setVirtualizer: (virtualizer: LayerTreeVirtualizer) => void
}
interface LayerTreeSlotScope {
actions: LayerTreeRootActions
draggingId: string | null
instruction: LayerDragInstruction | null
instructionTargetId: string | null
focused: boolean
}
defineOptions({ inheritAttrs: false })
const { ui } = defineProps<{ ui?: LayerTreeUI }>()
const { rowHeight, indent } = useLayerTreeGeometry()
const attrs = useAttrs()
const styles = tv(layerTreeTheme)()
provideLayerTreeUI(() => ui)
const store = useEditorStore()
const viewport = useTemplateRef<HTMLElement>('viewport')
/** How far the rows are scrolled, for the pinned top-level row. */
const { y: scrollTop } = useScroll(viewport)
let pendingScrollPosition: number | undefined
watch(
[rowHeight, () => store.state.currentPageId],
async ([height, pageId], [previousHeight, previousPageId], onCleanup) => {
const el = viewport.value
if (!el || pageId !== previousPageId) {
pendingScrollPosition = undefined
return
}
// Capture before the keyed virtualizer remount resets the viewport to zero.
pendingScrollPosition ??= el.scrollTop / previousHeight
const position = pendingScrollPosition
let cancelled = false
onCleanup(() => {
cancelled = true
})
await nextTick()
if (cancelled || viewport.value !== el) return
el.scrollTop = Math.min(position * height, Math.max(0, el.scrollHeight - el.clientHeight))
pendingScrollPosition = undefined
}
)
const rename = useInlineRename((id, name) => store.renameNode(id, name))
/** Issue marks follow the canvas markers' View → Design issues toggle. */
const issueMarks = computed(() => {
const snapshot = store.designCheck.snapshot.value
if (!appPreferences.value.designCheck.showOnCanvas) return null
if (!snapshot || snapshot.pageId !== store.state.currentPageId) return null
return layerIssueMarks(snapshot.issues, store.graph)
})
const renameControls = {
commit: rename.commit,
onKeydown: rename.onKeydown,
focusInput: rename.focusInput
}
watch(
() => store.state.renameNodeId,
(id) => {
if (!id) return
const node = store.graph.getNode(id)
store.state.renameNodeId = null
if (node) rename.start(node.id, node.name)
},
{ immediate: true }
)
/** Rename the pinned layer on its own row: scroll the list back to it, then start. */
async function renamePinned(id: string, name: string, index: number) {
if (viewport.value) viewport.value.scrollTop = index * rowHeight.value
await nextTick()
rename.start(id, name)
}
function onLayerRightClick(e: MouseEvent) {
const row = (e.target as HTMLElement).closest<HTMLElement>('[data-node-id]')
if (!row?.dataset.nodeId) return
if (!store.state.selectedIds.has(row.dataset.nodeId)) store.select([row.dataset.nodeId])
}
function layerSelectionMode(e: CustomEvent): LayerSelectionMode {
const mouseEvent = e.detail?.originalEvent as MouseEvent | undefined
return {
additive: !!(mouseEvent?.metaKey || mouseEvent?.ctrlKey),
range: !!mouseEvent?.shiftKey
}
}
function onTreeSelect(
e: CustomEvent,
id: string,
select: (id: string, selection: boolean | LayerSelectionMode) => void
) {
e.preventDefault()
select(id, layerSelectionMode(e))
}
function isLayerNode(value: unknown): value is LayerNode {
return (
typeof value === 'object' &&
value !== null &&
'id' in value &&
'name' in value &&
'type' in value &&
'layoutMode' in value &&
'visible' in value &&
'locked' in value &&
typeof value.id === 'string' &&
typeof value.name === 'string' &&
typeof value.type === 'string' &&
typeof value.layoutMode === 'string' &&
typeof value.visible === 'boolean' &&
typeof value.locked === 'boolean'
)
}
function toLayerNode(value: unknown): LayerNode {
if (isLayerNode(value)) return value
throw new Error('[open-pencil] Invalid layer tree item')
}
function layerTextContent(value: unknown): string {
return toLayerNode(value).name
}
function chrome(scope: Omit<LayerTreeSlotScope, 'actions'>) {
return {
draggingId: scope.draggingId,
instruction: scope.instruction,
instructionTargetId: scope.instructionTargetId,
focused: scope.focused,
indent: indent.value
}
}
/**
* Bring a row into view. A nested row stops below the top-level row pinned over the top of the
* list, so the pin never covers it; rows are one height, so their place is exact.
*/
function revealRow(rows: readonly LayerRow[], index: number) {
const el = viewport.value
const row = rows.at(index)
if (!el || !row) return
// A layer showing as the pinned row is in view already, so selecting it keeps the list still.
if (stickyTopLevelRow(rows, el.scrollTop, rowHeight.value)?.index === index) return
const top = index * rowHeight.value
const pinned = row.level > 1 ? rowHeight.value : 0
if (top - pinned < el.scrollTop) {
el.scrollTop = Math.max(0, top - pinned)
} else if (top + rowHeight.value > el.scrollTop + el.clientHeight) {
el.scrollTop = top + rowHeight.value - el.clientHeight
}
}
function registerVirtualizer(
actions: LayerTreeRootActions,
virtualizer: LayerTreeVirtualizer,
rows: () => readonly LayerRow[]
): boolean {
actions.setVirtualizer({
scrollToIndex: (index, options) => {
if ((options?.align ?? 'auto') === 'auto') revealRow(rows(), index)
else virtualizer.scrollToIndex(index, options)
}
})
return true
}
function onFocusOut(event: FocusEvent, actions: LayerTreeRootActions) {
const next = event.relatedTarget
if (
next instanceof Node &&
event.currentTarget instanceof Node &&
event.currentTarget.contains(next)
) {
return
}
actions.setFocused(false)
}
</script>
<template>
<LayerTreeRoot v-slot="scope" :indent-per-level="indent">
<ContextMenuRoot :modal="false">
<!-- The trigger covers the pinned row too, so right-clicking it opens the layer menu. -->
<ContextMenuTrigger as-child @contextmenu="onLayerRightClick">
<div
v-bind="attrs"
class="relative min-h-0 flex-1 overflow-hidden"
@focusin="scope.actions.setFocused(true)"
@focusout="onFocusOut($event, scope.actions)"
>
<div
ref="viewport"
data-test-id="layers-scroll"
data-slot="viewport"
:class="styles.viewport({ class: ui?.viewport })"
>
<TreeVirtualizer
v-slot="{ item, virtualizer }"
:key="rowHeight"
:estimate-size="rowHeight"
:text-content="layerTextContent"
>
<template
v-if="registerVirtualizer(scope.actions, virtualizer, () => scope.visibleRows)"
>
<TreeItem
v-slot="{ isExpanded }"
v-bind="item.bind"
as-child
@select="
(e: CustomEvent) =>
onTreeSelect(e, toLayerNode(item.value).id, scope.actions.select)
"
@toggle="
(e: CustomEvent) => {
if (e.detail.originalEvent?.type === 'click') e.preventDefault()
}
"
>
<LayerTreeItem
v-slot="{
node,
isSelected,
padLeft,
actions,
instruction,
instructionTargetId
}"
:node="toLayerNode(item.value)"
:level="item.level"
:has-children="item.hasChildren"
>
<LayerTreeRenameRow
v-if="rename.editingId.value === node.id"
:node="node"
:has-children="item.hasChildren"
:pad-left="padLeft"
:expanded="isExpanded"
:actions="actions"
:rename-controls="renameControls"
/>
<LayerTreeNodeRow
v-else
:node="node"
:level="item.level"
:has-children="item.hasChildren"
:selected="isSelected"
:pad-left="padLeft"
:expanded="isExpanded"
:actions="actions"
:issue="issueMarks?.get(node.id) ?? null"
:chrome="
chrome({
...scope,
instruction,
instructionTargetId
})
"
@rename-start="rename.start"
/>
</LayerTreeItem>
</TreeItem>
</template>
</TreeVirtualizer>
</div>
<LayerTreeStickyRow
:scroll-top="scrollTop"
:chrome="chrome({ ...scope, instruction: null, instructionTargetId: null })"
@rename-start="renamePinned"
/>
</div>
</ContextMenuTrigger>
<ContextMenuPortal>
<CanvasMenu />
</ContextMenuPortal>
</ContextMenuRoot>
</LayerTreeRoot>
</template>