Skip to content

AI-native design editor. Open-source Figma alternative.

20.7 KB
Raw Blame
import type { CanvasKit } from 'canvaskit-wasm'
import { createNanoEvents } from 'nanoevents'
import type { Emitter } from 'nanoevents'

import { SceneGraph, type SceneNode } from '@open-pencil/scene-graph'
import { UndoManager } from '@open-pencil/scene-graph/undo'

import type { SkiaRenderer } from '#core/canvas/renderer'
import { prefetchFigmaSchema } from '#core/clipboard'
import { IS_BROWSER } from '#core/constants'
import {
  getPageColor,
  hasStoredBackground,
  setDefaultPageBackground
} from '#core/figma-api/page-backgrounds'
import { defaultIcons } from '#core/icons'
import { releaseFigPopulationWorker } from '#core/kiwi/fig/population/client'
import { releaseOriginalFigArchive } from '#core/kiwi/fig/session/original-archive'
import { installTextMeasurer } from '#core/layout'
import { createLayoutRunner } from '#core/layout/mutations'
import { emitNavigationTrace } from '#core/profiler'
import { TextEditor } from '#core/text/editor'
import { fontManager } from '#core/text/font/manager'
import { prepareTextFonts } from '#core/text/prepare'
import { fontResolver } from '#core/text/resolver'

import { createAlignmentActions } from './alignment'
import { createClipboardBridge } from './bridges/clipboard'
import { createComponentBridge } from './bridges/components'
import { createFrameNavigationBridge } from './bridges/frames'
import { createLintFixBridge } from './bridges/lint'
import { createStructureBridge } from './bridges/structure'
import { createUndoBridge } from './bridges/undo'
import { createClipboardActions } from './clipboard'
import { createClipboardPropertiesActions } from './clipboard/paste/properties'
import { createColorSpaceActions } from './color-space'
import { createComponentSyncScheduler } from './component-sync'
import { createComponentActions } from './components'
import { createConnectorDrawActions, createConnectorEndpointActions } from './connectors/draw'
import { createConnectorLineActions } from './connectors/line'
import { createConnectorRouting } from './connectors/routing'
import { createConnectorStyleActions } from './connectors/style'
import { createDesignTokenActions } from './design-tokens'
import { createDocumentSettingsActions } from './document-settings'
import { createFigCompressionActions } from './fig-compression'
import { createFigJamColorActions } from './figjam/colors'
import { createGraphEventSubscription } from './graph-events'
import { createGraphReadActions } from './graph-reads'
import { createGuideActions } from './guides'
import { createIconActions } from './icons'
import { createDesignIssueActions } from './issues'
import { createLineEndActions } from './line-ends'
import { createNodeActions } from './nodes'
import { createPageActions } from './pages'
import { createReadOnlyActions, guardReadOnly, guardUndo } from './read-only'
import { createSelectionActions } from './selection'
import { createShaderActions } from './shaders/actions'
import { createShaderFrames } from './shaders/frames'
import { createShapeActions } from './shapes'
import { createShapeWithTextActions } from './shapes/with-text'
import { createDefaultEditorState } from './state'
import { createStatusActions } from './statuses'
import { createStickyActions } from './stickies'
import { createStructureActions } from './structure'
import { createTextActions } from './text'
import { createPendingTextLayout } from './text/pending-layout'
import { createTextSelectionStyle } from './text/selection-style'
import { createFigJamTextActions } from './text/typeface'
import type {
  EditorContext,
  EditorEventName,
  EditorEvents,
  EditorOptions,
  EditorState,
  RenderVersions
} from './types'
import { createUndoActions } from './undo'
import { createVariableActions } from './variables'
import { createVectorizeActions } from './vectorize'
import { createViewportActions } from './viewport'
import { createCanvasViewActions, offeredTool, resolveEditorProfile } from './views'

export { createDefaultEditorState } from './state'

export function createEditor(options?: EditorOptions) {
  let _graph = options?.graph ?? new SceneGraph()
  const skipInitialGraphSetup = options?.skipInitialGraphSetup ?? false
  const undo = new UndoManager({ onChange: () => emitEditorEvent('history:changed') })
  const _loadFont = options?.loadFont ?? fontManager.loadFont.bind(fontManager)
  const _getViewportSize =
    options?.getViewportSize ??
    (() => {
      if (IS_BROWSER) return { width: window.innerWidth, height: window.innerHeight }
      return { width: 800, height: 600 }
    })
  let _ck: CanvasKit | null = null
  let _renderer: SkiaRenderer | null = null
  const _renderers = new Set<SkiaRenderer>()
  let uninstallTextMeasurer: (() => void) | null = null
  const interactiveEdits = new Set<symbol>()
  let _textEditor: TextEditor | null = null
  const events: Emitter<EditorEvents> = createNanoEvents()
  const stopFontResolutionEvents = fontResolver.subscribe((event, snapshot) =>
    events.emit('font:resolution-changed', event, snapshot)
  )
  const stopFontLoadEvents = fontManager.onFaceLoaded((family, style) =>
    events.emit('font:loaded', family, style)
  )

  void prefetchFigmaSchema()

  const state: EditorState = options?.state ?? createDefaultEditorState(_graph.getPages()[0].id)
  state.documentKind = _graph.documentKind
  state.activeTool = offeredTool(state, state.activeTool)

  function emitEditorEvent<K extends EditorEventName>(
    event: K,
    ...args: Parameters<EditorEvents[K]>
  ) {
    events.emit(event, ...args)
  }

  function onEditorEvent<K extends EditorEventName>(event: K, handler: EditorEvents[K]) {
    return events.on(event, handler)
  }

  function requestRender() {
    state.renderVersion++
    state.sceneVersion++
    state.canvasVersion++
    emitNavigationTrace('render:requested', {
      kind: 'render',
      renderVersion: state.renderVersion,
      sceneVersion: state.sceneVersion
    })
    emitEditorEvent('render:requested', {
      renderVersion: state.renderVersion,
      sceneVersion: state.sceneVersion
    })
  }

  /**
   * The caret or selection of the edited text moved: the canvas repaints its overlay and the
   * views that follow the selection update, without the document counting as changed.
   */
  function textSelectionChanged() {
    state.textSelectionVersion++
    requestRepaint()
  }

  function requestRefresh() {
    state.sceneVersion++
  }

  /** A canvas showed a frame of `versions` with nothing left to fill in. */
  function reportPresented(versions: RenderVersions) {
    emitEditorEvent('render:presented', versions)
  }

  function requestRepaint() {
    state.renderVersion++
    emitNavigationTrace('render:requested', {
      kind: 'repaint',
      renderVersion: state.renderVersion,
      sceneVersion: state.sceneVersion
    })
    emitEditorEvent('repaint:requested', {
      renderVersion: state.renderVersion,
      sceneVersion: state.sceneVersion
    })
  }

  /** Track an actual live edit independently of history batching. Release is idempotent. */
  function beginInteractiveEdit() {
    const token = Symbol('interactive-edit')
    interactiveEdits.add(token)
    requestRepaint()
    return () => {
      if (interactiveEdits.delete(token)) requestRepaint()
    }
  }

  function setNavigationPhase(phase: EditorState['navigation']['phase'], inputAt = 0) {
    const previous = { ...state.navigation }
    const active = phase === 'pan' || phase === 'zoom' || phase === 'momentum'
    const wasActive =
      previous.phase === 'pan' || previous.phase === 'zoom' || previous.phase === 'momentum'
    state.navigation = {
      phase,
      generation: active && !wasActive ? previous.generation + 1 : previous.generation,
      lastInputAt: inputAt || previous.lastInputAt
    }
    if (
      state.navigation.phase !== previous.phase ||
      state.navigation.generation !== previous.generation ||
      state.navigation.lastInputAt !== previous.lastInputAt
    ) {
      emitNavigationTrace('navigation:phase', {
        phase: state.navigation.phase,
        previousPhase: previous.phase,
        generation: state.navigation.generation,
        lastInputAt: state.navigation.lastInputAt
      })
      emitEditorEvent('navigation:changed', state.navigation, previous)
    }
  }

  function setSelectedIds(ids: Set<string>) {
    const previous = [...state.selectedIds]
    state.selectedIds = ids
    if (ids.size === 0) state.measurementMode = 'off'
    const selected = [...ids]
    if (
      previous.length !== selected.length ||
      previous.some((id, index) => id !== selected[index])
    ) {
      emitEditorEvent('selection:changed', selected, previous)
    }
  }

  function setActiveTool(tool: EditorState['activeTool']) {
    if (offeredTool(state, tool) !== tool) return
    const previous = state.activeTool
    state.activeTool = tool
    if (tool !== 'SELECT') state.measurementMode = 'off'
    if (previous === tool) return
    // Guides the pen showed for its next point do not belong to the next tool.
    if (previous === 'PEN') state.snapGuides = []
    emitEditorEvent('tool:changed', tool, previous)
  }

  const graphReads = createGraphReadActions(() => _graph)
  const { runLayoutForNode, runMutationWithLayout } = createLayoutRunner(() => _graph)
  const pendingTextLayout = createPendingTextLayout({
    getGraph: () => _graph,
    getRenderer: () => _renderer,
    prepareFonts: (texts) => prepareTextFonts(texts, { loadFont: _loadFont }),
    runLayoutForNode,
    requestRender,
    onEditorEvent
  })
  const { scheduleComponentSync } = createComponentSyncScheduler(() => _graph, requestRender)

  const { subscribeToGraph, unsubscribeFromGraph } = createGraphEventSubscription({
    getGraph: () => _graph,
    getRenderers: () => _renderers,
    scheduleComponentSync,
    requestRender,
    emitEditorEvent
  })

  if (!skipInitialGraphSetup) {
    subscribeToGraph()
    // A new document's first page takes Figma's background for the interface theme the app gives;
    // a page that already has one keeps it.
    const firstPage = _graph.getPages()[0]
    if (options?.state?.theme && !hasStoredBackground(firstPage)) {
      setDefaultPageBackground(_graph, firstPage, options.state.theme)
      options.state.pageColor = getPageColor(firstPage)
    }
  }

  // Build the shared context
  const ctx: EditorContext = {
    get graph() {
      return _graph
    },
    set graph(g) {
      _graph = g
    },
    undo,
    state,
    loadFont: _loadFont,
    resolveFigmaClipboardImages: options?.resolveFigmaClipboardImages ?? null,
    getViewportSize: _getViewportSize,
    getUserName: () => options?.getUserName?.() ?? '',
    icons: options?.icons ?? defaultIcons,
    getCk: () => _ck,
    getRenderer: () => _renderer,
    getRenderers: () => _renderers,
    getTextEditor: () => _textEditor,
    requestRender,
    requestRefresh,
    requestRepaint,
    beginInteractiveEdit,
    onEditorEvent,
    emitEditorEvent,
    setSelectedIds,
    setActiveTool,
    setNavigationPhase,
    runLayoutForNode,
    runMutationWithLayout,
    subscribeToGraph
  }

  // Assemble domain modules
  const viewport = createViewportActions(ctx)
  const selection = createSelectionActions(ctx)
  const shaderFrames = createShaderFrames(ctx, options)
  const pages = createPageActions(ctx, shaderFrames)
  const guides = createGuideActions(ctx)
  const designIssues = createDesignIssueActions(ctx)
  const structure = createStructureActions(ctx)
  const components = createComponentActions(ctx)
  const clipboard = createClipboardActions(ctx)
  const colorSpace = createColorSpaceActions(ctx)
  const documentSettings = createDocumentSettingsActions(ctx)
  const undoActions = createUndoActions(ctx)
  const text = createTextActions(ctx)
  const nodes = createNodeActions(ctx)
  const shapes = createShapeActions(ctx, nodes.updateNodeWithUndo)
  const clipboardProperties = createClipboardPropertiesActions(
    ctx,
    nodes.updateNodeWithUndo,
    clipboard.loadFontsForNodes
  )
  const variables = createVariableActions(ctx)
  const designTokens = createDesignTokenActions(ctx, variables, nodes)
  const vectorize = createVectorizeActions(ctx)
  const icons = createIconActions(ctx)
  const stickies = createStickyActions(ctx, nodes)
  const shapesWithText = createShapeWithTextActions(ctx, nodes)
  const figJamText = createFigJamTextActions(ctx, nodes, { ...stickies, ...shapesWithText })
  const figJamColors = createFigJamColorActions(ctx, nodes)
  const statuses = createStatusActions(ctx)
  const figCompression = createFigCompressionActions(ctx)
  createConnectorRouting(ctx)
  const connectorDrawing = createConnectorDrawActions(ctx)
  const connectorEndpoints = createConnectorEndpointActions(
    ctx,
    nodes.beginNodePreview,
    clipboard.deleteNodes
  )
  const connectorLines = createConnectorLineActions(ctx, nodes.beginNodePreview)
  const connectorStyles = createConnectorStyleActions(ctx, nodes)
  const lineEnds = createLineEndActions(ctx, nodes.beginNodePreview)
  const shaders = createShaderActions(ctx, nodes)
  const alignment = createAlignmentActions(ctx)
  const canvasViews = createCanvasViewActions(ctx)
  const clipboardBridge = createClipboardBridge(clipboard, selection)
  const componentBridge = createComponentBridge(components, selection, structure, pages)
  const structureBridge = createStructureBridge(structure, selection)
  const frameNavigation = createFrameNavigationBridge(ctx, selection, viewport)
  const undoBridge = createUndoBridge(undoActions, selection, nodes.flushNudge)
  const lintFixBridge = createLintFixBridge(ctx, nodes, structure, clipboard)
  const textSelectionStyle = createTextSelectionStyle(ctx, text.runTextEditStep)
  /** Whether the editor refuses edits: its profile offers none, as for a read-only document. */
  const readsOnly = () => !resolveEditorProfile(state).edits
  const readOnly = createReadOnlyActions(ctx, () => {
    nodes.flushNudge()
    nodes.cancelNodePreviews()
    if (state.editingTextId) text.commitTextEdit()
    shapes.penCancel()
    shapes.pencilCancel()
    state.gradientEdit = null
  })

  // The edited text follows changes made outside the editor, such as a panel field being
  // dragged, so its caret and selection move with the text instead of after the change.
  const invalidateEditedText = (id: string) => {
    if (id !== state.editingTextId) return
    const node = _graph.getNode(id)
    if (node) _textEditor?.invalidateParagraph(node)
  }
  onEditorEvent('node:updated', invalidateEditedText)
  onEditorEvent('node:previewUpdated', invalidateEditedText)

  function setCanvasKit(ck: CanvasKit, renderer: SkiaRenderer) {
    _ck = ck
    _renderer = renderer
    _renderers.add(renderer)
    _textEditor ??= new TextEditor(ck)
    uninstallTextMeasurer?.()
    // Measures with the editor's current renderer, which removing this one falls back from.
    uninstallTextMeasurer =
      typeof renderer.measureTextNode === 'function'
        ? installTextMeasurer((node, maxWidth) =>
            _renderer ? pendingTextLayout.measure(_renderer, node, maxWidth) : null
          )
        : null
  }

  function releaseTextMeasurer() {
    uninstallTextMeasurer?.()
    uninstallTextMeasurer = null
  }

  function removeCanvasRenderer(renderer: SkiaRenderer) {
    _renderers.delete(renderer)
    if (_renderer === renderer) {
      _renderer = _renderers.values().next().value ?? null
    }
    if (_renderers.size === 0) releaseTextMeasurer()
  }

  function replaceGraph(newGraph: SceneGraph) {
    nodes.cancelNodePreviews()
    undo.discardBatches()
    pendingTextLayout.clear()
    _graph = newGraph
    state.documentKind = _graph.documentKind
    setActiveTool(offeredTool(state, state.activeTool))
    subscribeToGraph()
    const previousPageId = state.currentPageId
    state.currentPageId = _graph.getPages()[0]?.id ?? _graph.rootId
    setSelectedIds(new Set())
    state.hoveredNodeId = null
    state.transforming = false
    state.measurementMode = 'off'
    state.snapGuides = []
    state.guides = { preview: null, hovered: null, selected: null, redline: null }
    state.layoutInsertIndicator = null
    state.dropTargetId = null
    pages.clearPageViewports()
    for (const renderer of _renderers) renderer.tiledScene.invalidateStructure()
    emitEditorEvent('graph:replaced', _graph)
    if (previousPageId !== state.currentPageId) {
      emitEditorEvent('page:changed', state.currentPageId, previousPageId)
    }
    requestRender()
  }

  function dispose() {
    releaseTextMeasurer()
    nodes.cancelNodePreviews()
    interactiveEdits.clear()
    stopFontResolutionEvents()
    stopFontLoadEvents()
    unsubscribeFromGraph()
  }

  function releaseGraphResources() {
    releaseFigPopulationWorker(_graph)
    releaseOriginalFigArchive(_graph)
  }

  const editor = {
    get graph() {
      return _graph
    },
    get renderer() {
      return _renderer
    },
    get canvasRenderers() {
      return [..._renderers]
    },
    get textEditor() {
      return _textEditor
    },
    undo: guardUndo(undo, readsOnly),
    state,

    // Graph reads
    runLayoutForNode,
    runMutationWithLayout,
    ...graphReads,

    // Lifecycle
    beginInteractiveEdit,
    isInteractiveEditing: () => interactiveEdits.size > 0,
    requestRender,
    requestRefresh,
    textSelectionChanged,
    requestRepaint,
    reportPresented,
    onEditorEvent,
    setCanvasKit,
    setNavigationPhase,
    removeCanvasRenderer,
    replaceGraph,
    subscribeToGraph,
    dispose,
    releaseGraphResources,

    // Selection
    ...selection,

    // Pages
    ...pages,

    // Canvas and frame guides
    ...guides,
    ...designIssues,

    // Shapes & tools
    ...shapes,

    // Structure (group, reorder, reparent, z-order)
    ...structure,

    // Nodes (update, layout); while text is edited, character styles go to its selection
    ...nodes,
    updateNode: (id: string, changes: Partial<SceneNode>) =>
      textSelectionStyle.updateNode(id, changes, nodes.updateNode),
    updateNodeWithUndo: (id: string, changes: Partial<SceneNode>, label = 'Update') =>
      textSelectionStyle.updateNodeWithUndo(id, changes, (target, next) =>
        nodes.updateNodeWithUndo(target, next, label)
      ),
    getTextSelectionStyle: textSelectionStyle.selectionStyle,
    layerChanges: textSelectionStyle.layerChanges,

    // Alignment (align, flip, rotate)
    ...alignment,

    // Canvas views: editing, or a preview where instances with a behaviour respond to the pointer
    ...canvasViews,

    // Bitmap-to-vector replacement
    ...vectorize,
    ...icons,
    ...stickies,
    ...shapesWithText,
    ...figJamText,
    ...figJamColors,
    statusWorkflow: statuses.statusWorkflow,
    getShownStatus: statuses.getShownStatus,
    setStatus: statuses.setStatus,
    setStatusWorkflow: statuses.setStatusWorkflow,
    ...connectorDrawing,
    ...connectorEndpoints,
    ...connectorLines,
    ...lineEnds,
    ...connectorStyles,
    ...shaders,
    ...shaderFrames,

    // Variables
    ...variables,
    ...designTokens,

    // Text editing
    ...text,

    // Viewport
    ...viewport,
    ...frameNavigation,

    // Undo — bridge functions that need cross-module refs
    ...undoBridge,
    commitNodeUpdate: (id: string, previous: Partial<SceneNode>, label = 'Update') =>
      textSelectionStyle.commitNodeUpdate(
        id,
        previous,
        (target, values) => undoBridge.commitNodeUpdate(target, values, label),
        (target, next) => nodes.updateNodeWithUndo(target, next, label)
      ),
    // While text is edited, what was typed undoes first and the editor keeps the result.
    undoAction: () => text.runTextEditStep(undoBridge.undoAction),
    redoAction: () => text.runTextEditStep(undoBridge.redoAction),

    setDocumentColorSpace: colorSpace.setDocumentColorSpace,
    updateEnabledLibraries: documentSettings.updateEnabledLibraries,
    refreshDocumentSettings: documentSettings.refreshDocumentSettings,
    setDocumentKind: documentSettings.setDocumentKind,
    figCompression: figCompression.figCompression,
    setFigCompression: figCompression.setFigCompression,

    // Clipboard — bridge functions that need selectedNodes
    ...clipboardBridge,

    // Paste properties: the look of a copied layer, onto the selection
    ...clipboardProperties,

    // Components — bridge functions
    ...componentBridge,

    // Structure — bridge functions that need selectedNodes
    ...structureBridge,

    // Lint fixes, which touch nodes, structure and deletion in one undo step
    ...lintFixBridge,

    // Read-only documents, which refuse every action above that changes them
    ...readOnly
  }
  return guardReadOnly(editor, readsOnly)
}

/**
 * The editor `createEditor` returns. An interface rather than an alias, so declarations that
 * mention it, such as a Vue composable's inferred return type, name it instead of spelling out
 * its members, some of whose types are internal to Core.
 */
// eslint-disable-next-line typescript/no-empty-object-type -- The interface is the point: an alias's members are spelled out in emitted declarations.
export interface Editor extends ReturnType<typeof createEditor> {}