AI-native design editor. Open-source Figma alternative.
<script setup lang="ts">
import {
ContextMenuPortal,
ContextMenuRoot,
ContextMenuTrigger,
PopoverContent,
PopoverPortal,
PopoverRoot
} from 'reka-ui'
import { computed, onUnmounted, ref, shallowRef, useTemplateRef, watch, type Component } from 'vue'
import IconLucideAlignHorizontalSpaceBetween from '~icons/lucide/align-horizontal-space-between'
import IconLucideAlignVerticalSpaceBetween from '~icons/lucide/align-vertical-space-between'
import IconLucidePanelBottom from '~icons/lucide/panel-bottom'
import IconLucidePanelLeft from '~icons/lucide/panel-left'
import IconLucidePanelRight from '~icons/lucide/panel-right'
import IconLucidePanelTop from '~icons/lucide/panel-top'
import { resolveEditorProfile } from '@open-pencil/core'
import type { PlacedStatusLabel } from '@open-pencil/core/canvas'
import {
AUTO_LAYOUT_PADDING_EDITOR_OFFSET_X,
AUTO_LAYOUT_PADDING_EDITOR_OFFSET_Y,
COMPONENT_LABEL_ICON_GAP,
COMPONENT_LABEL_ICON_SIZE,
SECTION_TITLE_GAP,
SECTION_TITLE_HEIGHT
} from '@open-pencil/core/constants'
import type { ViewportTransform } from '@open-pencil/core/geometry'
import { PlayIslands, useCanvasInput } from '@open-pencil/vue/canvas'
import { useCanvasDrop } from '@open-pencil/vue/canvas/drop'
import { useEyedropperLoupe } from '@open-pencil/vue/canvas/eyedropper'
import { useCanvasIssueMarkers } from '@open-pencil/vue/canvas/issues'
import { useCanvasVirtualReference } from '@open-pencil/vue/canvas/overlays'
import { useCanvasStatusLabels } from '@open-pencil/vue/canvas/statuses'
import { useCanvas } from '@open-pencil/vue/canvas/surface'
import { useTextEdit } from '@open-pencil/vue/canvas/text-edit'
import { toolCursor } from '@open-pencil/vue/editor/tool-cursor'
import { autoLayoutValueAnchor, type AutoLayoutValueField } from '@open-pencil/vue/shared/input'
import { useAIChat } from '@/app/ai/chat/use'
import { useEditorStore } from '@/app/editor/active-store'
import { useCanvasCollaborationAwareness } from '@/app/editor/canvas/collaboration-awareness'
import { createCanvasContextSelection } from '@/app/editor/canvas/context-selection'
import { canvasOverlayObstacles } from '@/app/editor/canvas/obstacles'
import { useFollowView } from '@/app/presence/follow-view'
import { appRuntimeConfig } from '@/app/runtime/config'
import { appPreferences } from '@/app/settings/preferences/store'
import CanvasEyedropperLoupe from '@/components/canvas/CanvasEyedropperLoupe.vue'
import CommentsLayer from '@/components/comments/CommentsLayer.vue'
import IssueMarkerTooltip from '@/components/design-check/IssueMarkerTooltip.vue'
import SelectionToolbar from '@/components/figjam/SelectionToolbar.vue'
import PreparationOverlay from '@/components/preparation/canvas/PreparationOverlay.vue'
import FollowFrame from '@/components/presence/FollowFrame.vue'
import StatusLabelMenu from '@/components/statuses/StatusLabelMenu.vue'
import AppDropOverlay from '@/components/ui/feedback/AppDropOverlay.vue'
import { motionStyles } from '@/theme/motion/styles'
import { floatingSurface } from '@/theme/overlay'
import CanvasMenu from './canvas/CanvasMenu.vue'
import CanvasLabelEditor from './canvas/labels/CanvasLabelEditor.vue'
import { canvasLabelPresentation } from './canvas/labels/presentation'
import NumberField from './inputs/NumberField.vue'
const { paneId } = defineProps<{
paneId?: string
}>()
const store = useEditorStore()
const sceneCanvasRef = ref<HTMLCanvasElement | null>(null)
const canvasRef = ref<HTMLCanvasElement | null>(null)
const isActivePane = computed(() => !paneId || store.activePaneId.value === paneId)
const followView = useFollowView(useTemplateRef<HTMLElement>('area'))
function activatePane() {
if (paneId) store.setActivePane(paneId)
}
function updatePaneCursor(cx: number, cy: number) {
if (isActivePane.value) updateCursor(cx, cy)
}
const getRenderState = paneId ? () => store.getPaneRenderState(paneId) : undefined
/** This pane's view: its pan, zoom, page, and whether it previews. */
const paneView = computed(() => (paneId ? store.getPaneRenderState(paneId) : store.state))
const paneProfile = computed(() => resolveEditorProfile(paneView.value))
const onViewportResize = (width: number, height: number) => {
if (paneId) store.resizePane(paneId, width, height)
if (isActivePane.value) store.setViewportSize(width, height)
}
const { updateCursor } = useCanvasCollaborationAwareness(store)
const { selectAtContextPoint } = createCanvasContextSelection(canvasRef, store)
const shouldSuspendRender = () =>
store.state.preparation !== null &&
store.state.preparation.kind !== 'font-retry' &&
store.state.preparation.phase !== 'preparing-render'
/** The pan and zoom of the scene's last drawn frame, which preview islands follow. */
const drawnView = shallowRef<ViewportTransform | null>(null)
/** Where popovers on the canvas are placed: the drawn frame, or the live view before one is drawn. */
const overlayView = computed(() => drawnView.value ?? paneView.value)
// The tab's scene is presented only here once the canvas can draw, so waiting for it times out
// only while it is shown and drawing, not while the renderer and its fonts download.
let detachCanvas: (() => void) | null = null
onUnmounted(() => detachCanvas?.())
function canvasReady() {
store.markCanvasReady()
detachCanvas ??= store.preparationController.attachCanvas()
}
useCanvas(sceneCanvasRef, store, {
layer: 'scene',
onFrame: (view) => {
drawnView.value = view
},
onReady: canvasReady,
onFailed: (error) =>
store.preparationController.failCanvas(
new Error('The canvas could not start', { cause: error })
),
shouldSuspendRender,
showRulers: false,
getRenderState,
onViewportResize,
onPresentation: (colorSpace) => {
store.state.canvasPresentation = colorSpace
}
})
const {
hitTestSectionTitle,
hitTestComponentLabel,
hitTestFrameTitle,
hitTestIssueMarker,
hitTestStatusLabel
} = useCanvas(canvasRef, store, {
layer: 'overlays',
// The scene canvas reports a canvas that cannot start.
onFailed: () => undefined,
get showRulers() {
return (
appRuntimeConfig.showRulers &&
store.state.showRulers &&
paneProfile.value.editChrome &&
paneProfile.value.rulers
)
},
getOverlayObstacles: () => canvasOverlayObstacles(canvasRef.value),
shouldSuspendRender,
getRenderState,
onViewportResize
})
const {
drag,
cursorOverride,
canvasLabelEdit,
startCanvasLabelEdit,
updateCanvasLabelEdit,
commitCanvasLabelEdit,
cancelCanvasLabelEdit,
autoLayoutValueEdit,
updateAutoLayoutValueEdit,
commitAutoLayoutValueEdit,
cancelAutoLayoutValueEdit,
cleanupInteractions
} = useCanvasInput(
canvasRef,
store,
hitTestSectionTitle,
hitTestComponentLabel,
hitTestFrameTitle,
updatePaneCursor,
activatePane,
() => isActivePane.value,
() => appPreferences.value.navigation.zoomSpeed
)
watch(isActivePane, (active) => {
if (!active) cleanupInteractions()
})
onUnmounted(cleanupInteractions)
const { activeTab: propertiesTab } = useAIChat()
const openStatusLabel = shallowRef<PlacedStatusLabel | null>(null)
const { cursor: statusLabelCursor } = useCanvasStatusLabels(canvasRef, store, {
hitTest: hitTestStatusLabel,
onActivate: (label) => {
activatePane()
openStatusLabel.value = label
}
})
const { detailMarker: hoveredIssueMarker, cursor: issueMarkerCursor } = useCanvasIssueMarkers(
canvasRef,
store,
{
hitTest: hitTestIssueMarker,
onHover: (marker) => store.designCheck.highlightMarker(marker?.nodeIds ?? null),
onActivate: (marker) => {
activatePane()
propertiesTab.value = 'lint'
// An edge pin leads to its nearest issue; a marker opens every layer it covers.
const nodeIds = marker.direction ? marker.nodeIds.slice(0, 1) : marker.nodeIds
store.designCheck.openMarker(nodeIds)
if (marker.direction) store.revealNodes(nodeIds)
}
}
)
useTextEdit(canvasRef, store, { isEnabled: () => isActivePane.value })
const { isDraggingOver } = useCanvasDrop(canvasRef, store, activatePane)
const valueFieldIcons = {
paddingTop: IconLucidePanelTop,
paddingRight: IconLucidePanelRight,
paddingBottom: IconLucidePanelBottom,
paddingLeft: IconLucidePanelLeft
} satisfies Record<Exclude<AutoLayoutValueField, 'itemSpacing'>, Component>
const canvasLabelEditNode = computed(() => {
const edit = canvasLabelEdit.value
return edit ? store.graph.getNode(edit.nodeId) : null
})
const canvasLabelEditAnchor = computed(() => {
const node = canvasLabelEditNode.value
if (!node) return null
const origin = store.graph.getAbsolutePosition(node.id)
// The view the reference projects through, so screen-sized offsets match the drawn frame.
const { zoom, panX, panY } = overlayView.value
const kind = canvasLabelEdit.value?.kind
// The canvas starts an upright label on a whole screen pixel; the field starts on the same one.
const abs = {
x: (Math.round(origin.x * zoom + panX) - panX) / zoom,
y: (Math.round(origin.y * zoom + panY) - panY) / zoom
}
// A component's name starts after its diamond, which keeps its screen size at any zoom.
if (kind === 'component-label')
return { x: abs.x + (COMPONENT_LABEL_ICON_SIZE + COMPONENT_LABEL_ICON_GAP) / zoom, y: abs.y }
// A section inside another draws its title inside its top-left corner instead of above it.
const nested = node.parentId && store.graph.closest(node.parentId, (n) => n.type === 'SECTION')
if (kind === 'section-title' && nested) {
const inset = SECTION_TITLE_GAP / zoom
return {
x: abs.x + inset,
y: abs.y + inset + (SECTION_TITLE_HEIGHT + SECTION_TITLE_GAP) / zoom
}
}
return { x: abs.x, y: abs.y }
})
const canvasLabelEditReference = useCanvasVirtualReference(
canvasRef,
overlayView,
canvasLabelEditAnchor
)
const canvasLabelEditPresentation = computed(() =>
canvasLabelPresentation(store, canvasLabelEditNode.value ?? null, canvasLabelEdit.value?.kind)
)
/** Names the selected section on the canvas, as its title does on a double-click. */
function renameSelectedSection() {
const [id] = store.state.selectedIds
const section = id ? store.graph.getNode(id) : undefined
if (section?.type === 'SECTION') startCanvasLabelEdit('section-title', section)
}
// With the side panels away, a sticky, shape, or connector shows its controls over the canvas,
// as FigJam does.
const selectionToolbar = computed(
() =>
isActivePane.value &&
!store.state.showUI &&
paneProfile.value.edits &&
paneProfile.value.editChrome
)
const valueEditorAnchor = computed(() => {
const edit = autoLayoutValueEdit.value
return edit ? autoLayoutValueAnchor(store, edit.nodeId, edit.field, edit.gap) : null
})
const valueEditorReference = useCanvasVirtualReference(canvasRef, overlayView, valueEditorAnchor)
const valueEditorIcon = computed(() => {
const edit = autoLayoutValueEdit.value
if (!edit) return IconLucidePanelTop
if (edit.field !== 'itemSpacing') return valueFieldIcons[edit.field]
return store.graph.getNode(edit.nodeId)?.layoutMode === 'VERTICAL'
? IconLucideAlignVerticalSpaceBetween
: IconLucideAlignHorizontalSpaceBetween
})
const eyedropperLoupe = useEyedropperLoupe(store, canvasRef, () => isActivePane.value)
// The eyedropper's loupe stands in for the cursor while it shows.
const cursor = computed(() =>
eyedropperLoupe.visible.value
? 'none'
: toolCursor(
store.state.activeTool,
issueMarkerCursor.value ?? statusLabelCursor.value ?? cursorOverride.value
)
)
</script>
<template>
<ContextMenuRoot :modal="false">
<ContextMenuTrigger as-child @contextmenu.capture="selectAtContextPoint">
<div
ref="area"
data-test-id="canvas-area"
:data-pane-id="paneId"
:data-active-pane="isActivePane ? 'true' : 'false'"
class="canvas-area relative min-h-0 min-w-0 flex-1 overflow-hidden"
@pointerdown.capture="activatePane"
@focusin.capture="activatePane"
@wheel.capture="activatePane"
@dragenter.capture="activatePane"
>
<canvas
ref="sceneCanvasRef"
:data-pane-id="paneId"
data-test-id="scene-canvas-element"
aria-hidden="true"
class="pointer-events-none absolute inset-0 size-full outline-none"
/>
<canvas
ref="canvasRef"
:data-pane-id="paneId"
data-test-id="canvas-element"
tabindex="-1"
:style="{ cursor }"
class="absolute inset-0 block size-full touch-none outline-none"
/>
<PlayIslands :view="paneView" :drawn="drawnView" :canvas="canvasRef" />
<AppDropOverlay :visible="isDraggingOver" />
<IssueMarkerTooltip :marker="hoveredIssueMarker" :canvas="canvasRef" />
<CanvasEyedropperLoupe :loupe="eyedropperLoupe" />
<StatusLabelMenu
:label="openStatusLabel"
:canvas="canvasRef"
@close="openStatusLabel = null"
/>
<CanvasLabelEditor
:edit="canvasLabelEdit"
:presentation="canvasLabelEditPresentation"
:reference="canvasLabelEditReference"
@update="updateCanvasLabelEdit"
@commit="commitCanvasLabelEdit"
@cancel="cancelCanvasLabelEdit"
/>
<SelectionToolbar
v-if="selectionToolbar"
:canvas="canvasRef"
:view="overlayView"
:hidden="!!drag || !!canvasLabelEdit"
@rename-section="renameSelectedSection"
/>
<PopoverRoot :open="!!autoLayoutValueEdit">
<PopoverPortal>
<PopoverContent
v-if="autoLayoutValueEdit && valueEditorReference"
:reference="valueEditorReference"
side="top"
align="center"
:side-offset="AUTO_LAYOUT_PADDING_EDITOR_OFFSET_Y"
:align-offset="AUTO_LAYOUT_PADDING_EDITOR_OFFSET_X"
:collision-padding="8"
:class="['z-50 w-20 p-1', floatingSurface, motionStyles.floating]"
data-test-id="auto-layout-value-editor"
@keydown.escape.prevent="cancelAutoLayoutValueEdit"
@open-auto-focus.prevent
>
<NumberField
:model-value="autoLayoutValueEdit.value"
:min="0"
:step="1"
data-test-id="auto-layout-value-input"
@update:model-value="updateAutoLayoutValueEdit"
@commit="(value: number) => commitAutoLayoutValueEdit(value)"
@editing-change="
(editing: boolean) =>
!editing &&
autoLayoutValueEdit &&
commitAutoLayoutValueEdit(autoLayoutValueEdit.value)
"
>
<template #icon>
<component :is="valueEditorIcon" class="size-3.5" />
</template>
</NumberField>
</PopoverContent>
</PopoverPortal>
</PopoverRoot>
<FollowFrame
v-if="isActivePane && followView.label.value"
:followed="followView.label.value"
@stop="followView.stop"
/>
<CommentsLayer v-if="isActivePane" :canvas-el="canvasRef" :drawn="drawnView" />
<PreparationOverlay
v-if="store.state.preparation && store.state.preparation.kind !== 'font-retry'"
:preparation="store.state.preparation"
/>
</div>
</ContextMenuTrigger>
<ContextMenuPortal>
<CanvasMenu />
</ContextMenuPortal>
</ContextMenuRoot>
</template>