Skip to content

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

6.2 KB
Raw Blame
import type {
  LayoutAlign,
  LayoutCounterAlign,
  LayoutMode,
  LayoutSizing,
  SceneGraph,
  SceneNode
} from '@open-pencil/scene-graph'
import { parseAutoLayoutDirection } from '@open-pencil/scene-graph/layout'

import type { PenNode, PenNumber } from './schema'
import { bindIfVar, isVarRef, resolveNumber, type VarContext } from './variables'

const CORNERS = [
  'topLeftRadius',
  'topRightRadius',
  'bottomRightRadius',
  'bottomLeftRadius'
] as const
const PADDING = ['paddingTop', 'paddingRight', 'paddingBottom', 'paddingLeft'] as const

export function applyCornerRadius(
  node: SceneNode,
  radius: PenNode['cornerRadius'],
  ctx: VarContext
): void {
  if (radius === undefined) return
  if (Array.isArray(radius)) {
    node.independentCorners = true
    for (const [index, field] of CORNERS.entries()) {
      node[field] = resolveNumber(radius[index], ctx)
      bindIfVar(node, field, radius[index], ctx)
    }
    return
  }
  node.cornerRadius = resolveNumber(radius, ctx)
  bindIfVar(node, 'cornerRadius', radius, ctx)
}

/** pen.dev padding: one value, vertical and horizontal, or top, right, bottom, and left. */
function paddingSides(padding: NonNullable<PenNode['padding']>): PenNumber[] {
  if (!Array.isArray(padding)) return [padding, padding, padding, padding]
  if (padding.length === 2) return [padding[0], padding[1], padding[0], padding[1]]
  return padding
}

export function applyPadding(node: SceneNode, padding: PenNode['padding'], ctx: VarContext): void {
  if (padding === undefined) return
  const sides = paddingSides(padding)
  for (const [index, field] of PADDING.entries()) {
    node[field] = resolveNumber(sides[index], ctx)
    bindIfVar(node, field, sides[index], ctx)
  }
}

interface ParsedSize {
  value: number
  sizing: LayoutSizing
  /** Fallback used only when fit_content(N) has no children. */
  fitContentFallback?: number
}

function parseParameterizedFallback(value: string, behavior: string): number | undefined {
  const prefix = `${behavior}(`
  if (!value.startsWith(prefix) || !value.endsWith(')')) return undefined

  const rawFallback = value.slice(prefix.length, -1).trim()
  if (rawFallback === '') return undefined

  const parsedFallback = Number(rawFallback)
  return Number.isFinite(parsedFallback) ? parsedFallback : undefined
}

function parseSizingBehavior(value: string, fallback: number): ParsedSize | undefined {
  if (value === 'fill_container') return { value: fallback, sizing: 'FILL' }
  if (value === 'fit_content') return { value: fallback, sizing: 'HUG' }

  // Older generated .pen files used hug_content as an alias for fit_content.
  if (value === 'hug_content') return { value: fallback, sizing: 'HUG' }

  const fillFallback = parseParameterizedFallback(value, 'fill_container')
  if (fillFallback !== undefined) return { value: fillFallback, sizing: 'FILL' }

  const fitFallback =
    parseParameterizedFallback(value, 'fit_content') ??
    parseParameterizedFallback(value, 'hug_content')
  if (fitFallback !== undefined) {
    return { value: fitFallback, sizing: 'HUG', fitContentFallback: fitFallback }
  }
  return undefined
}

export function parseSize(
  value: number | string | undefined,
  fallback: number,
  ctx?: VarContext
): ParsedSize {
  if (value === undefined) return { value: fallback, sizing: 'FIXED' }
  if (typeof value === 'number') return { value, sizing: 'FIXED' }

  const behavior = parseSizingBehavior(value, fallback)
  if (behavior) return behavior

  if (isVarRef(value) && ctx) return { value: ctx.resolveNumber(value), sizing: 'FIXED' }
  const parsed = Number(value)
  return { value: Number.isFinite(parsed) ? parsed : fallback, sizing: 'FIXED' }
}

export function mapLayoutMode(pen: PenNode): LayoutMode {
  const direction = parseAutoLayoutDirection(pen.layout)
  if (direction) return direction
  return pen.type === 'frame' && pen.layout === undefined ? 'HORIZONTAL' : 'NONE'
}

/** pen.dev's main axis alignments; `space_around` lays out as `start` until {@link spreadAround}. */
const JUSTIFY_CONTENT: Partial<Record<string, LayoutAlign>> = {
  start: 'MIN',
  center: 'CENTER',
  end: 'MAX',
  space_between: 'SPACE_BETWEEN'
}

const ALIGN_ITEMS: Partial<Record<string, LayoutCounterAlign>> = {
  start: 'MIN',
  center: 'CENTER',
  end: 'MAX'
}

export function mapJustifyContent(value: string | undefined): LayoutAlign {
  return JUSTIFY_CONTENT[value ?? 'start'] ?? 'MIN'
}

export function mapAlignItems(value: string | undefined): LayoutCounterAlign {
  return ALIGN_ITEMS[value ?? 'start'] ?? 'MIN'
}

function flowChildren(graph: SceneGraph, frame: SceneNode): SceneNode[] {
  return graph
    .getChildren(frame.id)
    .filter((child) => child.visible && child.layoutPositioning !== 'ABSOLUTE')
}

/**
 * Auto layout has no `space_around`, which gives every child an equal share of the free space,
 * half of it on each side. Once laid out, the share goes into the gap and half of it into the
 * padding at both ends, which draws the same. Returns whether any frame changed.
 */
export function spreadAround(graph: SceneGraph, frameIds: readonly string[]): boolean {
  let changed = false
  for (const id of frameIds) {
    const frame = graph.getNode(id)
    if (!frame || frame.layoutMode === 'NONE' || frame.primaryAxisSizing !== 'FIXED') continue
    const children = flowChildren(graph, frame)
    if (children.length === 0) continue
    const horizontal = frame.layoutMode === 'HORIZONTAL'
    const used = children.reduce(
      (sum, child) => sum + (horizontal ? child.width : child.height),
      frame.itemSpacing * (children.length - 1)
    )
    const free = horizontal
      ? frame.width - frame.paddingLeft - frame.paddingRight - used
      : frame.height - frame.paddingTop - frame.paddingBottom - used
    if (free <= 0) continue
    const share = free / children.length
    if (horizontal) {
      graph.updateNode(frame.id, {
        itemSpacing: frame.itemSpacing + share,
        paddingLeft: frame.paddingLeft + share / 2,
        paddingRight: frame.paddingRight + share / 2
      })
    } else {
      graph.updateNode(frame.id, {
        itemSpacing: frame.itemSpacing + share,
        paddingTop: frame.paddingTop + share / 2,
        paddingBottom: frame.paddingBottom + share / 2
      })
    }
    changed = true
  }
  return changed
}