Skip to content

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

7.1 KB
Raw Blame
import type { Effect as KiwiEffect, Paint, VariableAliasValue } from '@open-pencil/kiwi/fig/codec'
import { guidToString, stringToGuid } from '@open-pencil/kiwi/fig/guid'
import type {
  Fill,
  Stroke,
  Effect,
  BlendMode,
  ImageScaleMode,
  GradientTransform,
  StrokeCap,
  StrokeJoin
} from '@open-pencil/scene-graph'
import { BLACK } from '@open-pencil/scene-graph/constants'
import type { Color, Matrix } from '@open-pencil/scene-graph/primitives'

import { hexToBytes } from './bytes'

export function safeColor(color: Color | Omit<Color, 'a'>): Color {
  return { r: color.r, g: color.g, b: color.b, a: 'a' in color ? color.a : 1 }
}

export function fillToKiwiPaint(fill: Fill): Paint {
  const paint: Paint = {
    type: fill.type,
    color: safeColor(fill.color),
    opacity: fill.opacity,
    visible: fill.visible,
    blendMode: fill.blendMode ?? 'NORMAL'
  }
  if (fill.gradientStops) {
    paint.stops = fill.gradientStops.map((stop) => ({
      color: safeColor(stop.color),
      position: stop.position
    }))
  }
  if (fill.gradientTransform) paint.transform = fill.gradientTransform
  if (fill.imageHash) paint.image = { hash: hexToBytes(fill.imageHash) }
  if (fill.imageScaleMode)
    paint.imageScaleMode = fill.imageScaleMode === 'CROP' ? 'STRETCH' : fill.imageScaleMode
  if (fill.imageTransform) paint.transform = fill.imageTransform
  if (fill.imageRotation) paint.rotation = fill.imageRotation
  if (fill.sourceNodeId) paint.sourceNodeId = stringToGuid(fill.sourceNodeId)
  if (fill.scale) paint.scale = fill.scale
  if (fill.spacing) paint.spacing = fill.spacing
  if (fill.patternSpacing) paint.patternSpacing = fill.patternSpacing
  if (fill.patternTileType) paint.patternTileType = fill.patternTileType
  if (fill.verticalAlignment) paint.verticalAlignment = fill.verticalAlignment
  if (fill.horizontalAlignment) paint.horizontalAlignment = fill.horizontalAlignment
  if (fill.noiseType) paint.noiseType = fill.noiseType
  if (fill.density !== undefined) paint.density = fill.density
  if (fill.noiseSize) paint.noiseSize = fill.noiseSize
  if (fill.customEffectId) paint.customEffectId = { guid: stringToGuid(fill.customEffectId) }
  return paint
}

function convertColor(color?: Partial<Color>): Color {
  if (!color) return { ...BLACK }
  return { r: color.r ?? 0, g: color.g ?? 0, b: color.b ?? 0, a: color.a ?? 1 }
}

function imageHashToString(hash: Record<string, number>): string {
  const bytes = Object.keys(hash)
    .sort((a, b) => Number(a) - Number(b))
    .map((k) => hash[Number(k)])
  return bytes.map((b) => b.toString(16).padStart(2, '0')).join('')
}

function convertGradientTransform(t?: Matrix): GradientTransform | undefined {
  if (!t) return undefined
  return { m00: t.m00, m01: t.m01, m02: t.m02, m10: t.m10, m11: t.m11, m12: t.m12 }
}

let variableColorResolver: ((alias: VariableAliasValue) => Color | null) | null = null

export function setVariableColorResolver(
  resolver: ((alias: VariableAliasValue) => Color | null) | null
): void {
  variableColorResolver = resolver
}

function resolveColorVar(paint: Paint): Color | undefined {
  const alias = paint.colorVar?.value?.alias
  if (!alias || !variableColorResolver) return undefined
  return variableColorResolver(alias) ?? undefined
}

function resolvedPaintColor(paint: Paint): { color: Color; opacity: number } {
  const resolved = resolveColorVar(paint)
  if (!resolved) return { color: convertColor(paint.color), opacity: paint.opacity ?? 1 }
  return {
    color: { ...resolved, a: paint.color?.a ?? 1 },
    opacity: paint.opacity ?? resolved.a
  }
}

function convertBaseFill(p: Paint): Fill {
  const { color, opacity } = resolvedPaintColor(p)
  return {
    type: p.type,
    color,
    opacity,
    visible: p.visible ?? true,
    blendMode: (p.blendMode ?? 'NORMAL') as BlendMode
  }
}

function applyGradientPaintFields(fill: Fill, p: Paint): void {
  if (!p.type.startsWith('GRADIENT') || !p.stops) return
  fill.gradientStops = p.stops.map((s) => ({
    color: convertColor(s.color),
    position: s.position
  }))
  if (p.transform) fill.gradientTransform = convertGradientTransform(p.transform)
}

function applyImagePaintFields(fill: Fill, p: Paint): void {
  if (p.type !== 'IMAGE') return
  if (p.image && typeof p.image === 'object') {
    const img = p.image as { hash: string | Record<string, number> }
    if (typeof img.hash === 'object') {
      fill.imageHash = imageHashToString(img.hash)
    } else if (typeof img.hash === 'string') {
      fill.imageHash = img.hash
    }
  }
  fill.imageScaleMode = (
    p.imageScaleMode === 'STRETCH' ? 'CROP' : (p.imageScaleMode ?? 'FILL')
  ) as ImageScaleMode
  // Figma writes an identity transform for Fill, Fit and Tile, and ignores what a Tile keeps from
  // an earlier crop; only a crop places the image by it.
  if (p.transform && fill.imageScaleMode === 'CROP')
    fill.imageTransform = convertGradientTransform(p.transform)
  if (p.rotation) fill.imageRotation = p.rotation
}

function applySchemaPaintFields(fill: Fill, p: Paint): void {
  if (p.sourceNodeId) fill.sourceNodeId = guidToString(p.sourceNodeId)
  if (p.scale) fill.scale = p.scale
  if (p.spacing) fill.spacing = p.spacing
  if (p.patternSpacing) fill.patternSpacing = p.patternSpacing
  if (p.patternTileType) fill.patternTileType = p.patternTileType as Fill['patternTileType']
  if (p.verticalAlignment) fill.verticalAlignment = p.verticalAlignment as Fill['verticalAlignment']
  if (p.horizontalAlignment)
    fill.horizontalAlignment = p.horizontalAlignment as Fill['horizontalAlignment']
  if (p.noiseType) fill.noiseType = p.noiseType as Fill['noiseType']
  if (p.density !== undefined) fill.density = p.density
  if (p.noiseSize) fill.noiseSize = p.noiseSize
  if (p.customEffectId?.guid) fill.customEffectId = guidToString(p.customEffectId.guid)
}

/** One Figma paint as a Scene Graph paint, whether it ends up a fill or a stroke. */
function convertPaint(p: Paint): Fill {
  const fill = convertBaseFill(p)
  applyGradientPaintFields(fill, p)
  applyImagePaintFields(fill, p)
  applySchemaPaintFields(fill, p)
  return fill
}

export function convertFills(paints?: Paint[]): Fill[] {
  if (!paints) return []
  return paints.map(convertPaint)
}

/** A Kiwi stroke alignment; Figma leaves out the centered default. */
export function convertStrokeAlign(align?: string): Stroke['align'] {
  return align === 'INSIDE' || align === 'OUTSIDE' ? align : 'CENTER'
}

export function convertStrokes(
  paints?: Paint[],
  weight?: number,
  align?: string,
  cap?: StrokeCap,
  join?: StrokeJoin,
  dashPattern?: number[]
): Stroke[] {
  if (!paints) return []
  const strokeAlign = convertStrokeAlign(align)

  return paints.map((p) => ({
    ...convertPaint(p),
    weight: weight ?? 1,
    align: strokeAlign,
    cap: cap ?? 'NONE',
    join: join ?? 'MITER',
    dashPattern: dashPattern ?? []
  }))
}

export function convertEffects(effects?: KiwiEffect[]): Effect[] {
  if (!effects) return []
  return effects.map((e) => ({
    type: e.type,
    color: convertColor(e.color),
    offset: e.offset ?? { x: 0, y: 0 },
    radius: e.radius ?? 0,
    spread: e.spread ?? 0,
    visible: e.visible ?? true,
    blendMode: (e.blendMode ?? 'NORMAL') as BlendMode,
    showShadowBehindNode: e.showShadowBehindNode ?? true
  }))
}