Skip to content

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

14.7 KB
Raw Blame
import { isEqual } from 'es-toolkit/predicate'

import type { CharacterStyleOverride, HyperlinkTarget, SceneNode } from '@open-pencil/scene-graph'
import {
  hasTextList,
  listNumberFormat,
  paragraphSpacingAt,
  paragraphStyleAt,
  textListItems,
  textParagraphRanges,
  type TextListItem,
  type TextParagraphRange
} from '@open-pencil/scene-graph/text'

import type { DesignElement, DesignNode, DesignStyleDeclaration } from '../types'
import { fillToCSS, letterSpacingToCSS, lineHeightToCSS } from './css'

/** The character styles CSS writes, as a text layer and its runs hold them. */
type CharacterStyle = Pick<
  SceneNode,
  | 'fontFamily'
  | 'fontSize'
  | 'fontWeight'
  | 'italic'
  | 'letterSpacing'
  | 'lineHeight'
  | 'fills'
  | 'textDecoration'
  | 'textDecorationStyle'
  | 'textDecorationThickness'
  | 'textDecorationFills'
  | 'textDecorationSkipInk'
  | 'textUnderlineOffset'
  | 'textCase'
>

type CharacterStyleKey = keyof CharacterStyle

const CHARACTER_STYLE_KEYS: readonly CharacterStyleKey[] = [
  'fontFamily',
  'fontSize',
  'fontWeight',
  'italic',
  'letterSpacing',
  'lineHeight',
  'fills',
  'textDecoration',
  'textDecorationStyle',
  'textDecorationThickness',
  'textDecorationFills',
  'textDecorationSkipInk',
  'textUnderlineOffset',
  'textCase'
]

/** A list's indent per level, in ems of its first character, as the canvas lays lists out. */
const LIST_INDENT_EMS = 1.5

const DECORATION_PROPERTIES = new Set([
  'text-decoration-line',
  'text-decoration-style',
  'text-decoration-color',
  'text-decoration-thickness',
  'text-underline-offset',
  'text-decoration-skip-ink'
])

const px = (value: number) => `${value}px`

/** Characters `[start, end)`, the run style over them, and where they link to. */
interface StyledRange {
  start: number
  end: number
  style: CharacterStyle
  href: string | null
}

/** Links a page can follow: to the web, to mail, or to a phone; others are left out. */
const LINK_PROTOCOLS = new Set(['http:', 'https:', 'mailto:', 'tel:'])

/** A link as an `href`, for a link to a URL a page can follow. */
function linkHref(link: HyperlinkTarget | null | undefined): string | null {
  if (link?.type !== 'URL') return null
  try {
    return LINK_PROTOCOLS.has(new URL(link.value).protocol) ? link.value : null
  } catch {
    // Not an absolute URL, which a page could not follow from anywhere it is placed.
    return null
  }
}

export function textCaseToCSS(value: SceneNode['textCase']): string | undefined {
  if (value === 'UPPER') return 'uppercase'
  if (value === 'LOWER') return 'lowercase'
  if (value === 'TITLE') return 'capitalize'
  return undefined
}

function characterStyle(node: SceneNode, override: CharacterStyleOverride = {}): CharacterStyle {
  const style = Object.fromEntries(CHARACTER_STYLE_KEYS.map((key) => [key, node[key]]))
  for (const key of CHARACTER_STYLE_KEYS) {
    const value = override[key]
    if (value !== undefined) style[key] = value
  }
  return style as CharacterStyle
}

/** The text in ranges of one style each: the runs, and the layer's own style between them. */
function styledRanges(node: SceneNode): StyledRange[] {
  const ranges: StyledRange[] = []
  const base = characterStyle(node)
  let at = 0
  for (const run of node.styleRuns.toSorted((a, b) => a.start - b.start)) {
    const start = Math.max(at, run.start)
    const end = Math.min(node.text.length, run.start + run.length)
    if (start > at) ranges.push({ start: at, end: start, style: base, href: null })
    if (end > start) {
      const href = linkHref(run.style.hyperlink)
      ranges.push({ start, end, style: characterStyle(node, run.style), href })
    }
    at = Math.max(at, end)
  }
  if (at < node.text.length) {
    ranges.push({ start: at, end: node.text.length, style: base, href: null })
  }
  return ranges
}

/** Underline or strikethrough as CSS writes it: Figma's offset is CSS's, from the baseline. */
function decorationCSS(style: CharacterStyle): DesignStyleDeclaration {
  if (style.textDecoration === 'NONE') return {}
  const underline = style.textDecoration === 'UNDERLINE'
  const css: DesignStyleDeclaration = {
    'text-decoration-line': underline ? 'underline' : 'line-through'
  }
  if (style.textDecorationStyle !== 'SOLID') {
    css['text-decoration-style'] = style.textDecorationStyle.toLowerCase()
  }
  const color = fillToCSS(style.textDecorationFills.find((fill) => fill.visible))
  if (color) css['text-decoration-color'] = color
  if (style.textDecorationThickness !== null) {
    css['text-decoration-thickness'] = px(style.textDecorationThickness)
  }
  if (underline && style.textUnderlineOffset !== null) {
    css['text-underline-offset'] = px(style.textUnderlineOffset)
  }
  if (underline && !style.textDecorationSkipInk) css['text-decoration-skip-ink'] = 'none'
  return css
}

function characterCSS(style: CharacterStyle, decorated: boolean): DesignStyleDeclaration {
  return {
    color: fillToCSS(style.fills.at(0)) ?? '',
    'font-family': style.fontFamily,
    'font-size': px(style.fontSize),
    'font-weight': String(style.fontWeight),
    'font-style': style.italic ? 'italic' : 'normal',
    'letter-spacing': letterSpacingToCSS(style.letterSpacing),
    'line-height': style.lineHeight === null ? 'normal' : lineHeightToCSS(style.lineHeight),
    'text-transform': textCaseToCSS(style.textCase) ?? 'none',
    ...(decorated ? decorationCSS(style) : {})
  }
}

/** What `css` sets differently from `base`. */
function differing(
  css: DesignStyleDeclaration,
  base: DesignStyleDeclaration
): DesignStyleDeclaration {
  return Object.fromEntries(
    Object.entries(css).filter(([property, value]) => value !== '' && base[property] !== value)
  )
}

/**
 * Whether the text decorates every character alike. CSS draws an element's decoration through
 * its descendants, which cannot take it off, so mixed decorations go on the spans instead.
 */
function uniformDecoration(node: SceneNode, ranges: readonly StyledRange[]): boolean {
  const decorations = ranges
    .filter((range) => node.text.slice(range.start, range.end).replaceAll('\n', '') !== '')
    .map((range) => decorationCSS(range.style))
  return decorations.every((decoration) => isEqual(decoration, decorations[0]))
}

interface TextProjection {
  node: SceneNode
  ranges: StyledRange[]
  base: DesignStyleDeclaration
  decorated: boolean
}

function textNode(text: string): DesignNode {
  return { type: 'text', text }
}

function element(
  tagName: string,
  inlineStyle: DesignStyleDeclaration,
  children: DesignNode[]
): DesignElement {
  return { type: 'element', tagName, attrs: {}, inlineStyle, children }
}

/**
 * A link styled as the text around it: a link draws in the text's colour and with only the
 * decoration its characters have, as in Figma, not in a browser's link style.
 */
function linkElement(href: string, css: DesignStyleDeclaration, text: string): DesignElement {
  const style = { color: 'inherit', 'text-decoration-line': 'none', ...css }
  return { ...element('a', style, [textNode(text)]), attrs: { href } }
}

/**
 * `text[start, end)` as text and spans, each span setting only what differs from the layer;
 * linked characters are a link instead.
 */
function inlineContent(projection: TextProjection, start: number, end: number): DesignNode[] {
  const { node, ranges, base, decorated } = projection
  const pieces: { css: DesignStyleDeclaration; text: string; href: string | null }[] = []
  for (const range of ranges) {
    const from = Math.max(start, range.start)
    const to = Math.min(end, range.end)
    if (to <= from) continue
    const css = differing(characterCSS(range.style, !decorated), base)
    const text = node.text.slice(from, to)
    const previous = pieces.at(-1)
    if (previous && previous.href === range.href && isEqual(previous.css, css)) {
      previous.text += text
    } else pieces.push({ css, text, href: range.href })
  }
  return pieces.map(({ css, text, href }) => {
    if (href) return linkElement(href, css, text)
    return Object.keys(css).length === 0 ? textNode(text) : element('span', css, [textNode(text)])
  })
}

/** A paragraph's content; an empty one holds a line break, which gives it a line's height. */
function paragraphContent(projection: TextProjection, range: TextParagraphRange): DesignNode[] {
  if (range.end === range.start) return [element('br', {}, [])]
  return inlineContent(projection, range.start, range.end)
}

/** Text that CSS lays out in one element: no lists, and no spacing or indent between lines. */
function needsBlocks(node: SceneNode): boolean {
  if (hasTextList(node)) return true
  const paragraphs = textParagraphRanges(node.text)
  return paragraphs.some(
    (_, index) =>
      paragraphSpacingAt(node, index, 'paragraphIndent') > 0 ||
      (index < paragraphs.length - 1 && paragraphSpacingAt(node, index, 'paragraphSpacing') > 0)
  )
}

/** The space after paragraph `index`: list spacing between two items, paragraph spacing else. */
function spaceAfter(node: SceneNode, index: number, count: number): number {
  if (index >= count - 1) return 0
  const betweenItems =
    paragraphStyleAt(node.textParagraphs, index).listType !== 'NONE' &&
    paragraphStyleAt(node.textParagraphs, index + 1).listType !== 'NONE'
  return paragraphSpacingAt(node, index, betweenItems ? 'listSpacing' : 'paragraphSpacing')
}

function listStyleType(item: TextListItem): string {
  if (item.listType === 'UNORDERED') return 'disc'
  const format = listNumberFormat(item.level)
  if (format === 'LOWER_ALPHA') return 'lower-alpha'
  if (format === 'LOWER_ROMAN') return 'lower-roman'
  return 'decimal'
}

/** A list in the text, open at one level, with the item that nested lists go into. */
interface OpenList {
  level: number
  listType: TextListItem['listType']
  element: DesignElement
  item: DesignElement | undefined
}

/** Where the next list item goes: closes lists deeper than it, or of another kind at its level. */
function closeListsFor(open: OpenList[], item: TextListItem): void {
  while ((open.at(-1)?.level ?? 0) > item.level) open.pop()
  const top = open.at(-1)
  if (top?.level === item.level && (top.listType !== item.listType || item.startsList)) open.pop()
}

/**
 * Opens a list one level below the innermost open one, inside its last item; a level an item
 * skips gets an item without a marker to hold it.
 */
function openList(
  open: OpenList[],
  blocks: DesignNode[],
  item: TextListItem,
  indent: number
): void {
  const parent = open.at(-1)
  const level = (parent?.level ?? 0) + 1
  const list = element(
    item.listType === 'ORDERED' ? 'ol' : 'ul',
    {
      ...blockMargins(0, 0),
      'padding-inline-start': px(indent),
      'list-style-type': level === item.level ? listStyleType(item) : 'none'
    },
    []
  )
  if (parent) {
    parent.item ??= appendTo(parent.element, element('li', { 'list-style-type': 'none' }, []))
    // The space after the item the list nests in stands above the list.
    const spacing = parent.item.inlineStyle?.['margin-bottom']
    if (spacing && parent.item.inlineStyle && list.inlineStyle) {
      delete parent.item.inlineStyle['margin-bottom']
      list.inlineStyle['margin-top'] = spacing
    }
    parent.item.children.push(list)
  } else blocks.push(list)
  open.push({ level, listType: item.listType, element: list, item: undefined })
}

function plainParagraph(
  projection: TextProjection,
  index: number,
  range: TextParagraphRange,
  after: number
): DesignElement {
  const style = blockMargins(0, after)
  const indent = paragraphSpacingAt(projection.node, index, 'paragraphIndent')
  if (indent > 0) style['text-indent'] = px(indent)
  return element('p', style, paragraphContent(projection, range))
}

/**
 * The text as blocks, as Figma lays it out: a paragraph per plain one, lists nested by level
 * with Figma's markers (bullets at every level, numbers counting 1, a, i as they nest), and the
 * space after each paragraph as a margin on what ends it.
 */
function blockContent(projection: TextProjection): DesignNode[] {
  const { node } = projection
  const paragraphs = textParagraphRanges(node.text)
  const items = new Map(
    textListItems(node.text, node.textParagraphs).map((item) => [item.paragraph, item])
  )
  const blocks: DesignNode[] = []
  const open: OpenList[] = []
  for (const [index, range] of paragraphs.entries()) {
    const after = spaceAfter(node, index, paragraphs.length)
    const item = items.get(index)
    if (!item) {
      open.length = 0
      blocks.push(plainParagraph(projection, index, range, after))
      continue
    }
    const unit = groupEm(projection, paragraphs, item) * LIST_INDENT_EMS
    closeListsFor(open, item)
    while ((open.at(-1)?.level ?? 0) < item.level) {
      // A hanging list's markers stand outside the text, so its first level has no indent.
      const first = open.length === 0
      openList(open, blocks, item, first && node.hangingList ? 0 : unit)
    }
    const list = open.at(-1)
    if (!list) continue
    const style: DesignStyleDeclaration = after > 0 ? { 'margin-bottom': px(after) } : {}
    list.item = appendTo(list.element, element('li', style, paragraphContent(projection, range)))
  }
  return blocks
}

/** Margins above and below a block, written out: paragraphs and lists have their own in CSS. */
function blockMargins(top: number, bottom: number): DesignStyleDeclaration {
  return { 'margin-top': px(top), 'margin-bottom': px(bottom) }
}

function appendTo(parent: DesignElement, child: DesignElement): DesignElement {
  parent.children.push(child)
  return child
}

/** The size of a list's first character, which its indents are measured in. */
function groupEm(
  projection: TextProjection,
  paragraphs: readonly TextParagraphRange[],
  item: TextListItem
): number {
  const at = paragraphs[item.groupStart]?.start ?? item.start
  const range = projection.ranges.find((candidate) => at >= candidate.start && at < candidate.end)
  return range?.style.fontSize ?? projection.node.fontSize
}

/**
 * A text layer's element: its tag, its style with the decoration the whole text shares, and
 * its content. Runs of characters styled apart become spans; text with lists, paragraph
 * spacing, or a first-line indent becomes blocks, which a `<div>` holds.
 */
export function textElementContent(
  node: SceneNode,
  layerStyle: DesignStyleDeclaration
): { tagName: string; style: DesignStyleDeclaration; children: DesignNode[] } {
  const ranges = styledRanges(node)
  const decorated = uniformDecoration(node, ranges)
  const style = Object.fromEntries(
    Object.entries(layerStyle).filter(([property]) => !DECORATION_PROPERTIES.has(property))
  )
  if (decorated) Object.assign(style, decorationCSS(characterStyle(node)))
  const projection: TextProjection = {
    node,
    ranges,
    base: characterCSS(characterStyle(node), decorated),
    decorated
  }
  if (!needsBlocks(node)) {
    return { tagName: 'span', style, children: inlineContent(projection, 0, node.text.length) }
  }
  return { tagName: 'div', style, children: blockContent(projection) }
}