Skip to content

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

16.7 KB
Raw Blame
<script setup lang="ts">
import { useDebounceFn } from '@vueuse/core'
import { tv } from 'tailwind-variants'
import {
  computed,
  defineAsyncComponent,
  onBeforeUnmount,
  ref,
  shallowRef,
  nextTick,
  useTemplateRef,
  watch
} from 'vue'

import { resolveEditorProfile } from '@open-pencil/core'
import { JSX_REFERENCE } from '@open-pencil/design-jsx'
import type { SceneNode } from '@open-pencil/scene-graph'
import { useEditorEvent } from '@open-pencil/vue/editor/events'
import { useI18n } from '@open-pencil/vue/i18n'

import {
  commitDOMCodeSession,
  createDOMCodeSession,
  previewDOMCode,
  resetDOMCodePreview,
  type DOMCodeSession
} from '@/app/code/dom-preview'
import { generatedCodeAsync, generatedDesignJSX } from '@/app/code/generated'
import { useCodeLayers } from '@/app/code/layers/use'
import {
  createDesignJSXEditSession,
  previewDesignJSX,
  reapplyCanvasEdits,
  resetDesignJSXPreview,
  type DesignJSXEditSession,
  type DesignJSXLayerLine
} from '@/app/code/live-preview'
import { codeStyling } from '@/app/code/styling'
import { starterSourceFor, type CodeSource } from '@/app/code/templates'
import { useEditorStore } from '@/app/editor/active-store'
import AppButton from '@/components/ui/button/AppButton.vue'
import AppCopyButton from '@/components/ui/button/AppCopyButton.vue'
import AppPlaceholder from '@/components/ui/feedback/AppPlaceholder.vue'
import AppSelect from '@/components/ui/select/AppSelect.vue'
import SegmentedControl from '@/components/ui/select/SegmentedControl.vue'
import statusTheme from '@/theme/feedback/status'

const CodeEditor = defineAsyncComponent(() => import('@/components/code-editor/CodeEditor.vue'))

const { active = true, initialSource = 'design-jsx' } = defineProps<{
  active?: boolean
  /** The code shown first; a host that showcases components can open on Vue or React. */
  initialSource?: CodeSource
}>()
const store = useEditorStore()
const editorActive = computed(() => active)
const { code, common } = useI18n()
const source = ref<CodeSource>(initialSource)
const draft = ref('')
/** The person has written in the code since it was generated for the current selection. */
const edited = ref(false)
const status = ref<'idle' | 'updating' | 'updated' | 'error'>('idle')
const error = ref('')
const designSession = shallowRef<DesignJSXEditSession | null>(null)
const codeEditor = useTemplateRef<InstanceType<typeof CodeEditor>>('codeEditor')
let domSession: DOMCodeSession | null = null
let previewQueue = Promise.resolve()
let pendingPreview: Promise<void> | undefined
let commitPromise: Promise<void> | undefined
let updateVersion = 0
/** Previews in flight; their canvas changes come from the code, not onto it. */
let previewing = 0
/** Scene version a preview left the canvas at, which the code already describes. */
let previewedVersion: number | null = null
/** The selection the code was generated for. */
let followedSelection: string | null = null
/** Code typed since the last preview started, which the canvas does not show yet. */
let previewDue = false
/**
 * Canvas edits made while code waits to render. Code replaced as a whole has no links to patch
 * them into until its preview links it again, so they are applied once more after that preview.
 */
let canvasEdits = new Map<string, Partial<SceneNode>>()

useEditorEvent('node:updated', (id, changes) => {
  if (!previewDue || previewing > 0 || source.value !== 'design-jsx') return
  canvasEdits.set(id, { ...canvasEdits.get(id), ...structuredClone(changes) })
})

function takeCanvasEdits(): Map<string, Partial<SceneNode>> {
  const edits = canvasEdits
  canvasEdits = new Map()
  previewDue = false
  return edits
}

/** Hands edits taken by a superseded or failed preview to the next one, behind any made since. */
function returnCanvasEdits(edits: ReadonlyMap<string, Partial<SceneNode>>) {
  for (const [id, changes] of edits) canvasEdits.set(id, { ...changes, ...canvasEdits.get(id) })
}

/** Set by "Write JSX": the editor stays open for new layers until something is selected. */
const composing = ref(false)

/**
 * Generated code needs a selection; without one the panel says so instead of showing a
 * template that looks like a real layer. Writing new Design JSX is an explicit action.
 */
const showEmptyState = computed(
  () =>
    source.value !== 'html-css' &&
    store.state.selectedIds.size === 0 &&
    !composing.value &&
    !designSession.value &&
    !edited.value
)

watch(
  () => store.state.selectedIds.size,
  (size) => {
    if (size > 0) composing.value = false
  }
)

function writeJSX() {
  composing.value = true
}
const codeLayers = useCodeLayers(source)

const sourceOptions = computed(() => [
  { value: 'design-jsx' as const, label: code.value.sourceDesignJSX },
  { value: 'html-css' as const, label: code.value.sourceHTML },
  { value: 'vue' as const, label: code.value.sourceVue },
  { value: 'react' as const, label: code.value.sourceReact }
])
const stylingOptions = computed(() => [
  { value: 'css', label: code.value.stylingCSS },
  { value: 'tailwind', label: code.value.stylingTailwind }
])
/** Components are generated; Design JSX and HTML are edited into layers. */
const readOnly = computed(() => source.value === 'vue' || source.value === 'react')
/** A read-only document's code is read, never previewed or applied back. */
const codeReadOnly = computed(() => readOnly.value || !resolveEditorProfile(store.state).edits)
const editorLabel = computed(() => {
  if (source.value === 'html-css') return code.value.editorHTMLCSSLabel
  if (source.value === 'vue') return code.value.sourceVue
  if (source.value === 'react') return code.value.sourceReact
  return code.value.editorDesignLabel
})
/** What the empty state says each generated source shows for a selection. */
const emptyDescription = computed(() => {
  if (source.value === 'design-jsx') return code.value.noSelectionDesignJSX
  return code.value.noSelectionComponents({ framework: editorLabel.value })
})
const statusTone = computed(() => {
  if (status.value === 'error') return 'error'
  if (status.value === 'updated') return 'success'
  return 'neutral'
})
const statusStyles = computed(() => tv(statusTheme)({ tone: statusTone.value }))

const statusText = computed(() => {
  if (status.value === 'updating') return code.value.updating
  if (status.value === 'error') return code.value.previewFailed
  if (edited.value) return code.value.updatedLive
  return code.value.jsxUpToDate
})

function beginDesignSession(): DesignJSXEditSession | null {
  if (designSession.value) return designSession.value
  const result = createDesignJSXEditSession(store)
  if (!result.ok) {
    status.value = 'error'
    error.value = result.error
    return null
  }
  designSession.value = result.session
  return result.session
}

function beginDOMSession(): DOMCodeSession {
  domSession ??= createDOMCodeSession(store)
  return domSession
}

/** Design JSX previews are recorded as they apply; an HTML/CSS preview is committed here. */
async function commitCurrentSession(): Promise<void> {
  if (commitPromise) return commitPromise
  const operation = (async () => {
    await pendingPreview
    await previewQueue
    updateVersion += 1
    takeCanvasEdits()
    const dom = domSession
    designSession.value = null
    domSession = null
    if (dom) commitDOMCodeSession(store, dom)
    pendingPreview = undefined
  })()
  commitPromise = operation
  try {
    await operation
  } finally {
    if (commitPromise === operation) commitPromise = undefined
  }
}

async function runPreview(version: number): Promise<void> {
  if (version !== updateVersion || codeReadOnly.value || !draft.value.trim()) return
  const edits = takeCanvasEdits()
  status.value = 'updating'
  error.value = ''
  previewing += 1
  let result: { ok: true } | { ok: false; error: string }
  let previewLayers: DesignJSXLayerLine[] | null = null
  try {
    if (source.value === 'html-css') {
      result = await previewDOMCode(store, beginDOMSession(), draft.value, codeStyling.value)
    } else {
      const session = beginDesignSession()
      const preview = session
        ? await previewDesignJSX(store, session, draft.value)
        : ({ ok: false, error: error.value } as const)
      if (preview.ok) previewLayers = preview.layers
      result = preview
    }
  } finally {
    previewing -= 1
    previewedVersion = store.state.sceneVersion
    followedSelection = selectionKey.value
  }
  if (version !== updateVersion) {
    returnCanvasEdits(edits)
    return
  }
  if (previewLayers) codeLayers.showPreview(previewLayers)
  if (!result.ok) {
    status.value = 'error'
    error.value = result.error
    // The code still waits to render, so its next preview applies these and later edits.
    previewDue = true
    returnCanvasEdits(edits)
    return
  }
  status.value = 'updated'
  const session = designSession.value
  if (!session || edits.size === 0) return
  // Once the code is linked again, the edits reach it as canvas changes do.
  await nextTick()
  if (version === updateVersion) reapplyCanvasEdits(store, session, edits)
  else returnCanvasEdits(edits)
}

const schedulePreview = useDebounceFn(
  (version: number) => {
    previewQueue = previewQueue.then(() => runPreview(version))
    return previewQueue
  },
  350,
  { maxWait: 1_000 }
)

function updateDraft(value: string, origin: 'user' | 'layers'): void {
  draft.value = value
  // Patches from the canvas already match it; only the person's typing renders.
  if (origin === 'layers') return
  edited.value = true
  error.value = ''
  updateVersion += 1
  previewDue = true
  pendingPreview = schedulePreview(updateVersion)
}

async function resetDraft(): Promise<void> {
  updateVersion += 1
  await pendingPreview
  await previewQueue
  takeCanvasEdits()
  const design = designSession.value
  const dom = domSession
  designSession.value = null
  domSession = null
  if (design) resetDesignJSXPreview(store, design)
  if (dom) resetDOMCodePreview(store, dom)
  pendingPreview = undefined
  error.value = ''
  status.value = 'idle'
  edited.value = false
  showCanvas(source.value)
}

/** Keeps what the current code previewed, then shows the selection in another format or styling. */
async function regenerate(change: () => void): Promise<void> {
  await commitCurrentSession()
  change()
  edited.value = false
  error.value = ''
  status.value = 'idle'
  showCanvas(source.value)
}

function changeSource(next: CodeSource): Promise<void> | undefined {
  if (next === source.value) return
  return regenerate(() => (source.value = next))
}

function changeStyling(next: string): Promise<void> | undefined {
  if (next === codeStyling.value || (next !== 'css' && next !== 'tailwind')) return
  return regenerate(() => (codeStyling.value = next))
}

const selectionKey = computed(() => [...store.state.selectedIds].join(','))

/** Generations of components and HTML in flight; only the latest shows. */
let generation = 0

/** Shows the code generated for the selection, replacing whatever the editor held. */
function showCanvas(next: CodeSource) {
  const selected = [...store.state.selectedIds]
  followedSelection = selectionKey.value
  if (next === 'design-jsx') {
    const generated = generatedDesignJSX(store.graph, selected)
    codeLayers.showGenerated(generated)
    draft.value = generated.code
    return
  }
  const current = ++generation
  if (selected.length === 0) {
    codeLayers.showGenerated(null)
    if (next === 'html-css') draft.value = starterSourceFor(next, codeStyling.value)
    return
  }
  const styling = codeStyling.value
  void generatedCodeAsync(next, styling, store.graph, selected).then((generated) => {
    if (current !== generation || source.value !== next || codeStyling.value !== styling)
      return generated
    codeLayers.showGenerated(generated)
    draft.value = generated.code
    return generated
  })
}

/**
 * Keeps the code in step with the canvas, like the Design panel. Code nobody has written in is
 * generated again; code the person wrote is patched where layers changed, keeping the rest as
 * written. Another selection starts over with its generated code.
 */
function followCanvas(live = false) {
  const current = source.value
  if (!editorActive.value || previewing > 0) return
  if (selectionKey.value !== followedSelection) {
    // HTML/CSS written for the last selection is kept as it was previewed.
    if (current === 'html-css' && edited.value) void commitCurrentSession()
    if (designSession.value) designSession.value = null
    edited.value = false
  }
  if (!edited.value) {
    showCanvas(current)
    return
  }
  // HTML/CSS someone wrote stays as written: unlike Design JSX, it has no links to patch.
  if (current === 'html-css') return
  // A live preview leaves the scene version alone, so it is followed whatever the version.
  if (!live && store.state.sceneVersion === previewedVersion) return
  codeEditor.value?.patchFromLayers()
}

watch([() => store.state.sceneVersion, selectionKey, source, editorActive], () => followCanvas(), {
  immediate: true
})

/** Dragging or scrubbing a value previews it; the code follows once per frame, like the Design panel. */
let livePreviewFrame = 0
useEditorEvent('node:previewUpdated', () => {
  if (livePreviewFrame) return
  livePreviewFrame = requestAnimationFrame(() => {
    livePreviewFrame = 0
    followCanvas(true)
  })
})

onBeforeUnmount(() => {
  cancelAnimationFrame(livePreviewFrame)
  void commitCurrentSession()
})

watch(
  () => editorActive.value,
  (value) => {
    if (!value) void commitCurrentSession()
  }
)
</script>

<template>
  <div data-test-id="code-panel-root" class="flex min-h-0 flex-1 flex-col">
    <header class="flex shrink-0 items-center gap-2 border-b border-border px-3 py-2">
      <AppSelect
        :model-value="source"
        :options="sourceOptions"
        :label="code.source"
        data-test-id="code-panel-source"
        :ui="{ trigger: 'h-7 min-w-0 flex-1 text-2xs' }"
        @update:model-value="changeSource"
      />
      <SegmentedControl
        v-if="source !== 'design-jsx'"
        :model-value="codeStyling"
        :options="stylingOptions"
        :label="code.styling"
        data-test-id="code-panel-styling"
        :ui="{ root: 'shrink-0' }"
        @update:model-value="changeStyling"
      />
      <AppCopyButton
        v-if="source === 'design-jsx'"
        icon
        :value="JSX_REFERENCE"
        :label="code.copyJSXReference"
        :copied-label="common.copied"
        data-test-id="code-panel-copy-ref"
      >
        <template #icon><icon-lucide-book-open class="size-3" aria-hidden="true" /></template>
      </AppCopyButton>
    </header>

    <AppPlaceholder
      v-if="showEmptyState"
      :label="code.noSelection"
      :description="emptyDescription"
      :fill="false"
      :ui="{ root: 'pt-10' }"
      data-test-id="code-panel-empty"
    >
      <template #icon>
        <icon-lucide-code class="size-4" />
      </template>
      <template v-if="source === 'design-jsx'" #action>
        <AppButton color="neutral" variant="soft" size="xs" @click="writeJSX">
          <icon-lucide-pencil class="size-3" />
          {{ code.writeJSX }}
        </AppButton>
      </template>
    </AppPlaceholder>

    <div v-else class="flex min-h-0 flex-1 flex-col overflow-hidden">
      <CodeEditor
        ref="codeEditor"
        :autofocus="composing"
        :model-value="draft"
        :language="source"
        :read-only="codeReadOnly"
        :label="editorLabel"
        :layer-links="codeLayers.links.value"
        :layer-issues="codeLayers.issues.value"
        @update:model-value="updateDraft"
        :describe-layer="source === 'design-jsx' ? codeLayers.describe : undefined"
        :layer-snippet="source === 'design-jsx' ? codeLayers.snippet : undefined"
        @active-layers="codeLayers.markActive"
      />
    </div>

    <div
      v-if="error"
      role="alert"
      data-test-id="code-panel-error"
      class="shrink-0 border-t border-error-border bg-error-bg px-3 py-2 text-2xs leading-snug text-error"
    >
      {{ error }}
    </div>

    <footer
      v-if="!showEmptyState"
      class="flex shrink-0 items-center justify-between gap-2 border-t border-border px-3 py-2"
    >
      <span
        data-test-id="code-panel-status"
        class="min-w-0 truncate"
        :data-tone="statusTone"
        :class="statusStyles.text()"
      >
        {{ readOnly ? code.generatedReadOnly : statusText }}
      </span>
      <div class="flex items-center gap-1">
        <AppButton
          v-if="edited && !codeReadOnly"
          color="neutral"
          variant="ghost"
          size="xs"
          data-test-id="code-panel-reset"
          @click="resetDraft"
        >
          <icon-lucide-rotate-ccw class="size-3" />
          {{ code.reset }}
        </AppButton>
        <AppCopyButton
          :value="draft"
          :label="common.copy"
          :copied-label="common.copied"
          size="xs"
          data-test-id="code-panel-copy"
        />
      </div>
    </footer>
  </div>
</template>