Skip to content

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

17.4 KB
Raw Blame
import { arrowCapOverflow } from './arrow-caps'
import type { Rect, Vector } from './primitives'
import { textLinesOverflow } from './text/overflow'
import type { Effect, Stroke, StrokeCap, StrokeJoin, VectorNetwork } from './types'

export { cubicPoint } from './cubic'

export function degToRad(degrees: number): number {
  return (degrees * Math.PI) / 180
}

export function radToDeg(radians: number): number {
  return (radians * 180) / Math.PI
}

export function rotatePoint(px: number, py: number, cx: number, cy: number, rad: number): Vector {
  const cos = Math.cos(rad)
  const sin = Math.sin(rad)
  return {
    x: cx + (px - cx) * cos - (py - cy) * sin,
    y: cy + (px - cx) * sin + (py - cy) * cos
  }
}

export function rotatedCorners(
  cx: number,
  cy: number,
  hw: number,
  hh: number,
  rotationDeg: number
): [Vector, Vector, Vector, Vector] {
  const rad = degToRad(rotationDeg)
  const cos = Math.cos(rad)
  const sin = Math.sin(rad)
  return [
    { x: cx + -hw * cos - -hh * sin, y: cy + -hw * sin + -hh * cos },
    { x: cx + hw * cos - -hh * sin, y: cy + hw * sin + -hh * cos },
    { x: cx + hw * cos - hh * sin, y: cy + hw * sin + hh * cos },
    { x: cx + -hw * cos - hh * sin, y: cy + -hw * sin + hh * cos }
  ]
}

export function rotatedBBox(
  x: number,
  y: number,
  w: number,
  h: number,
  rotationDeg: number
): { left: number; right: number; top: number; bottom: number; centerX: number; centerY: number } {
  if (rotationDeg === 0) {
    return {
      left: x,
      right: x + w,
      top: y,
      bottom: y + h,
      centerX: x + w / 2,
      centerY: y + h / 2
    }
  }
  const corners = rotatedCorners(x + w / 2, y + h / 2, w / 2, h / 2, rotationDeg)
  let left = Infinity,
    right = -Infinity,
    top = Infinity,
    bottom = -Infinity
  for (const c of corners) {
    left = Math.min(left, c.x)
    right = Math.max(right, c.x)
    top = Math.min(top, c.y)
    bottom = Math.max(bottom, c.y)
  }
  return { left, right, top, bottom, centerX: (left + right) / 2, centerY: (top + bottom) / 2 }
}

export interface VisualBounds {
  minX: number
  minY: number
  maxX: number
  maxY: number
}

type BoundsAccumulator = VisualBounds

function createBoundsAccumulator(): BoundsAccumulator {
  return { minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity }
}

function includePoint(bounds: BoundsAccumulator, x: number, y: number): void {
  bounds.minX = Math.min(bounds.minX, x)
  bounds.minY = Math.min(bounds.minY, y)
  bounds.maxX = Math.max(bounds.maxX, x)
  bounds.maxY = Math.max(bounds.maxY, y)
}

function includeRect(bounds: BoundsAccumulator, rect: Rect): void {
  includePoint(bounds, rect.x, rect.y)
  includePoint(bounds, rect.x + rect.width, rect.y + rect.height)
}

function boundsToRect(bounds: BoundsAccumulator): Rect {
  return bounds.minX === Infinity
    ? { x: 0, y: 0, width: 0, height: 0 }
    : {
        x: bounds.minX,
        y: bounds.minY,
        width: bounds.maxX - bounds.minX,
        height: bounds.maxY - bounds.minY
      }
}

export function computeBounds(items: Iterable<Rect>): Rect {
  const bounds = createBoundsAccumulator()
  for (const item of items) includeRect(bounds, item)
  return boundsToRect(bounds)
}

export function polygonVertices(node: {
  width: number
  height: number
  pointCount: number
  type: string
  starInnerRadius: number
}): Vector[] {
  const cx = node.width / 2
  const cy = node.height / 2
  const rx = node.width / 2
  const ry = node.height / 2
  const pointCount = Math.max(3, node.pointCount)
  const isStar = node.type === 'STAR'
  const innerRatio = isStar ? node.starInnerRadius : 1
  const totalPoints = isStar ? pointCount * 2 : pointCount
  const angleOffset = -Math.PI / 2

  return Array.from({ length: totalPoints }, (_, index) => {
    const angle = angleOffset + (2 * Math.PI * index) / totalPoints
    const isInner = isStar && index % 2 === 1
    const radius = isInner ? innerRatio : 1
    return {
      x: cx + rx * radius * Math.cos(angle),
      y: cy + ry * radius * Math.sin(angle)
    }
  })
}

/**
 * What shapes how far a layer's stroke reaches past its box: its type, since a line is stroked to
 * one side, and its join and miter limit, for the tips mitered path corners reach.
 */
export interface StrokeShape {
  type?: string
  strokeJoin?: StrokeJoin
  strokeMiterLimit?: number
}

export function strokeOverflow(
  strokes?: Stroke[],
  fallbackCap?: StrokeCap,
  network?: VectorNetwork | null,
  shape?: StrokeShape
): number {
  const line = shape?.type === 'LINE'
  // Open segments enclose nothing to take a side of, so their strokes draw centred; a network
  // with closed regions still strokes those on their side.
  const enclosed = new Set(network?.regions.flatMap((region) => region.loops.flat()))
  const open = network?.segments.some((_, index) => !enclosed.has(index)) ?? false
  const sided = !network || network.regions.length > 0
  let overflow = 0
  for (const stroke of strokes ?? []) {
    if (!stroke.visible) continue
    const align = sided ? stroke.align : 'CENTER'
    let extra = open ? stroke.weight / 2 : 0
    if (line || align === 'OUTSIDE') extra = stroke.weight
    else if (align === 'CENTER') extra = stroke.weight / 2
    const miter = network
      ? miterRatio(network, stroke.join ?? shape?.strokeJoin, shape?.strokeMiterLimit)
      : 1
    overflow = Math.max(overflow, extra * miter)
  }
  // A line's heads sit on its stroke's middle, half a weight off the line.
  const heads = arrowCapOverflow(strokes, fallbackCap, network)
  return Math.max(overflow, heads > 0 && line ? heads + overflow / 2 : heads)
}

/** The direction a segment leaves `vertex` in, along its handle when it has one. */
function leaving(network: VectorNetwork, index: number, vertex: number): Vector {
  const segment = network.segments[index]
  const atStart = segment.start === vertex
  const handle = atStart ? segment.tangentStart : segment.tangentEnd
  if (handle.x !== 0 || handle.y !== 0) return handle
  const from = network.vertices[vertex]
  const to = network.vertices[atStart ? segment.end : segment.start]
  return { x: to.x - from.x, y: to.y - from.y }
}

/**
 * How far past half the stroke the sharpest mitered corner reaches, as a multiple: a corner of
 * angle θ mitres out to 1/sin(θ/2), unless that passes the miter limit and it bevels instead.
 * Corners are the vertices exactly two segments meet at, as the stroke joins them.
 */
function miterRatio(network: VectorNetwork, join: StrokeJoin | undefined, limit = 4): number {
  const meeting = new Map<number, number[]>()
  for (const [index, segment] of network.segments.entries()) {
    for (const vertex of new Set([segment.start, segment.end])) {
      meeting.set(vertex, [...(meeting.get(vertex) ?? []), index])
    }
  }
  let ratio = 1
  for (const [vertex, indices] of meeting) {
    if (indices.length !== 2) continue
    if ((network.vertices[vertex].strokeJoin ?? join ?? 'MITER') !== 'MITER') continue
    const a = leaving(network, indices[0], vertex)
    const b = leaving(network, indices[1], vertex)
    const lengths = Math.hypot(a.x, a.y) * Math.hypot(b.x, b.y)
    if (lengths === 0) continue
    const angle = Math.acos(Math.max(-1, Math.min(1, (a.x * b.x + a.y * b.y) / lengths)))
    const miter = 1 / Math.sin(angle / 2)
    if (miter <= limit) ratio = Math.max(ratio, miter)
  }
  return ratio
}

/**
 * The blur radius Figma draws: a negative one, which only a bound variable can give, draws as no
 * blur, though the layer keeps the value.
 */
export function drawnBlurRadius(radius: number): number {
  return Math.max(0, radius)
}

const BLUR_SIGMA_PER_RADIUS = 0.43

/**
 * The Gaussian sigma that draws a Figma blur radius as Figma does. Measured on Figma 126 exports,
 * layer blur, both shadows, and background blur fall off as a Gaussian of 0.43 × radius; Figma's
 * SVG export writes radius / 2, which is wider (`packages/core/tests/canvas/blur.test.ts`).
 */
export function blurSigma(radius: number): number {
  return drawnBlurRadius(radius) * BLUR_SIGMA_PER_RADIUS
}

/** The Figma blur radius that draws a Gaussian of `sigma`, the inverse of `blurSigma`. */
export function blurRadiusForSigma(sigma: number): number {
  return Math.max(0, sigma) / BLUR_SIGMA_PER_RADIUS
}

export function effectOverflow(effects?: Effect[]) {
  let left = 0
  let right = 0
  let top = 0
  let bottom = 0

  for (const effect of effects ?? []) {
    if (!effect.visible) continue
    if (
      effect.type !== 'DROP_SHADOW' &&
      effect.type !== 'LAYER_BLUR' &&
      effect.type !== 'FOREGROUND_BLUR'
    ) {
      continue
    }
    const blurSpread = drawnBlurRadius(effect.radius) + effect.spread
    left = Math.max(left, blurSpread + Math.max(0, -effect.offset.x))
    right = Math.max(right, blurSpread + Math.max(0, effect.offset.x))
    top = Math.max(top, blurSpread + Math.max(0, -effect.offset.y))
    bottom = Math.max(bottom, blurSpread + Math.max(0, effect.offset.y))
  }

  return { left, right, top, bottom }
}

export function computeAbsoluteBounds(
  nodes: Iterable<{ id: string; width: number; height: number }>,
  getAbsolutePosition: (id: string) => Vector
): Rect {
  const bounds = createBoundsAccumulator()
  for (const n of nodes) {
    const abs = getAbsolutePosition(n.id)
    includeRect(bounds, { x: abs.x, y: abs.y, width: n.width, height: n.height })
  }
  return boundsToRect(bounds)
}

export function computeVisualBounds(
  nodes: Iterable<
    {
      id: string
      width: number
      height: number
      rotation?: number
      strokes?: Stroke[]
      strokeCap?: StrokeCap
      vectorNetwork?: VectorNetwork | null
      effects?: Effect[]
    } & StrokeShape
  >,
  getAbsolutePosition: (id: string) => Vector
): Rect {
  const bounds = createBoundsAccumulator()

  for (const n of nodes) {
    const abs = getAbsolutePosition(n.id)
    const bbox = rotatedBBox(abs.x, abs.y, n.width, n.height, n.rotation ?? 0)
    const stroke = strokeOverflow(n.strokes, n.strokeCap, n.vectorNetwork, n)
    const effects = effectOverflow(n.effects)
    includePoint(bounds, bbox.left - stroke - effects.left, bbox.top - stroke - effects.top)
    includePoint(bounds, bbox.right + stroke + effects.right, bbox.bottom + stroke + effects.bottom)
  }

  return boundsToRect(bounds)
}

export interface VisualBoundsNode {
  id: string
  width: number
  height: number
  rotation?: number
  flipX?: boolean
  flipY?: boolean
  strokes?: Stroke[]
  strokeCap?: StrokeCap
  vectorNetwork?: VectorNetwork | null
  effects?: Effect[]
  fillGeometry?: Array<{ commandsBlob: Uint8Array }>
  strokeGeometry?: Array<{ commandsBlob: Uint8Array }>
  childIds?: string[]
  visible?: boolean
  type?: string
  clipsContent?: boolean
  fontSize?: number
  textDecoration?: string
  textUnderlineOffset?: number | null
  textDecorationThickness?: number | null
  derivedTextHeight?: number | null
}

export function unionVisualBounds(
  a: VisualBounds | null,
  b: VisualBounds | null
): VisualBounds | null {
  if (!a) return b
  if (!b) return a
  return {
    minX: Math.min(a.minX, b.minX),
    minY: Math.min(a.minY, b.minY),
    maxX: Math.max(a.maxX, b.maxX),
    maxY: Math.max(a.maxY, b.maxY)
  }
}

export function intersectVisualBounds(a: VisualBounds, b: VisualBounds): VisualBounds | null {
  const minX = Math.max(a.minX, b.minX)
  const minY = Math.max(a.minY, b.minY)
  const maxX = Math.min(a.maxX, b.maxX)
  const maxY = Math.min(a.maxY, b.maxY)
  return minX < maxX && minY < maxY ? { minX, minY, maxX, maxY } : null
}

/** The path commands of a Figma geometry blob, by their byte code. */
export const GeometryCommand = { CLOSE: 0, MOVE: 1, LINE: 2, QUAD: 3, CUBIC: 4 } as const
export type GeometryCommand = (typeof GeometryCommand)[keyof typeof GeometryCommand]

/**
 * Coordinate pairs per command: glyph-derived blobs are quad-heavy, so every code needs its
 * count. Unknown codes are null, so readers stop instead of desyncing into coordinate bytes.
 */
function commandCoordCount(command: number): number | null {
  if (command === GeometryCommand.CLOSE) return 0
  if (command === GeometryCommand.MOVE || command === GeometryCommand.LINE) return 1
  if (command === GeometryCommand.QUAD) return 2
  if (command === GeometryCommand.CUBIC) return 3
  return null
}

/**
 * Walks a Figma geometry blob: `visit` gets each command, its coordinates as x, y pairs in one
 * array reused between calls, and the byte offset of the first coordinate. It stops at an
 * unknown command or one cut short.
 */
export function readGeometryBlob(
  blob: Uint8Array,
  visit: (command: GeometryCommand, coords: readonly number[], offset: number) => void
): void {
  const view = new DataView(blob.buffer, blob.byteOffset, blob.byteLength)
  const coords: number[] = []
  let offset = 0
  while (offset < blob.length) {
    const command = blob[offset]
    const count = commandCoordCount(command)
    if (count === null || offset + 1 + count * 8 > blob.length) return
    offset += 1
    coords.length = 0
    for (let i = 0; i < count; i++) {
      coords.push(view.getFloat32(offset + i * 8, true), view.getFloat32(offset + i * 8 + 4, true))
    }
    visit(command as GeometryCommand, coords, offset)
    offset += count * 8
  }
}

export function geometryBlobBounds(paths: Array<{ commandsBlob: Uint8Array }>): Rect | null {
  const bounds = createBoundsAccumulator()
  for (const path of paths) {
    readGeometryBlob(path.commandsBlob, (_, coords) => {
      for (let i = 0; i < coords.length; i += 2) includePoint(bounds, coords[i], coords[i + 1])
    })
  }

  return bounds.minX === Infinity ? null : boundsToRect(bounds)
}

function transformLocalPoint(node: VisualBoundsNode, point: Vector): Vector {
  let x = node.flipX ? node.width - point.x : point.x
  let y = node.flipY ? node.height - point.y : point.y
  const rotation = node.rotation ?? 0
  if (rotation !== 0) {
    const rotated = rotatePoint(x, y, node.width / 2, node.height / 2, degToRad(rotation))
    x = rotated.x
    y = rotated.y
  }
  return { x, y }
}

function transformedLocalBounds(node: VisualBoundsNode, local: Rect, abs: Vector): VisualBounds {
  const points = [
    { x: local.x, y: local.y },
    { x: local.x + local.width, y: local.y },
    { x: local.x + local.width, y: local.y + local.height },
    { x: local.x, y: local.y + local.height }
  ].map((point) => transformLocalPoint(node, point))

  return {
    minX: abs.x + Math.min(...points.map((point) => point.x)),
    minY: abs.y + Math.min(...points.map((point) => point.y)),
    maxX: abs.x + Math.max(...points.map((point) => point.x)),
    maxY: abs.y + Math.max(...points.map((point) => point.y))
  }
}

export function nodeVisualBounds(
  node: VisualBoundsNode,
  getAbsolutePosition: (id: string) => Vector
): VisualBounds {
  const abs = getAbsolutePosition(node.id)
  const base = computeVisualBounds([node], getAbsolutePosition)
  let bounds: VisualBounds = {
    minX: base.x,
    minY: base.y,
    maxX: base.x + base.width,
    maxY: base.y + base.height
  }

  const hasNonInsideStroke = node.strokes?.some(
    (stroke) => stroke.visible && stroke.align !== 'INSIDE'
  )
  const localGeometry = geometryBlobBounds([
    ...(node.fillGeometry ?? []),
    ...(hasNonInsideStroke ? (node.strokeGeometry ?? []) : [])
  ])
  if (localGeometry) {
    bounds = unionVisualBounds(bounds, transformedLocalBounds(node, localGeometry, abs)) ?? bounds
  }

  const linesOverflow = textLinesOverflow(node)
  if (linesOverflow > 0) {
    const lines = { x: 0, y: 0, width: node.width, height: node.height + linesOverflow }
    bounds = unionVisualBounds(bounds, transformedLocalBounds(node, lines, abs)) ?? bounds
  }

  bounds.maxY += textDecorationOverflow(node)

  return bounds
}

/** How far a text node's underline or strikethrough reaches below its box. */
export function textDecorationOverflow(node: VisualBoundsNode): number {
  if (node.type !== 'TEXT' || !node.textDecoration || node.textDecoration === 'NONE') return 0
  const fontSize = node.fontSize ?? 14
  const underlineOffset = node.textUnderlineOffset ?? fontSize * 0.18
  const thickness = node.textDecorationThickness ?? Math.max(1, fontSize / 16)
  return underlineOffset + thickness + fontSize * 0.35
}

function collectDescendantVisualBounds(
  nodeId: string,
  getNode: (id: string) => VisualBoundsNode | undefined,
  getAbsolutePosition: (id: string) => Vector,
  clip: VisualBounds | null = null
): VisualBounds | null {
  const node = getNode(nodeId)
  if (!node?.visible) return null

  const own = nodeVisualBounds(node, getAbsolutePosition)
  let bounds = clip ? intersectVisualBounds(own, clip) : own

  const isClippableContainer =
    node.type === 'FRAME' || node.type === 'COMPONENT' || node.type === 'INSTANCE'
  let childClip = clip
  if (isClippableContainer && node.clipsContent) {
    const abs = getAbsolutePosition(node.id)
    const nodeClip = {
      minX: abs.x,
      minY: abs.y,
      maxX: abs.x + node.width,
      maxY: abs.y + node.height
    }
    childClip = childClip ? intersectVisualBounds(childClip, nodeClip) : nodeClip
    if (!childClip) return bounds
  }

  for (const childId of node.childIds ?? []) {
    bounds = unionVisualBounds(
      bounds,
      collectDescendantVisualBounds(childId, getNode, getAbsolutePosition, childClip)
    )
  }

  return bounds
}

export function computeDescendantVisualBounds(
  nodeIds: string[],
  getNode: (id: string) => VisualBoundsNode | undefined,
  getAbsolutePosition: (id: string) => Vector
): VisualBounds | null {
  let bounds: VisualBounds | null = null
  for (const nodeId of nodeIds) {
    bounds = unionVisualBounds(
      bounds,
      collectDescendantVisualBounds(nodeId, getNode, getAbsolutePosition)
    )
  }
  return bounds
}