AI-native design editor. Open-source Figma alternative.
import { serializeHTML } from '../export/html'
import type {
CSSComputeOptions,
CSSRuntime,
DesignDocument,
DesignElement,
DesignNode
} from '../types'
export interface BrowserCSSRuntimeOptions {
document?: Document
sandbox?: 'shadow-root' | 'iframe'
}
const DEFAULT_COMPUTED_PROPERTIES = [
'align-items',
'aspect-ratio',
'background-color',
'background-image',
'border-bottom-color',
'border-bottom-style',
'border-bottom-left-radius',
'border-bottom-right-radius',
'border-bottom-width',
'border-left-color',
'border-left-style',
'border-left-width',
'border-radius',
'border-right-color',
'border-right-style',
'border-right-width',
'border-top-color',
'border-top-style',
'border-top-left-radius',
'border-top-right-radius',
'border-top-width',
'box-shadow',
'box-sizing',
'color',
'column-gap',
'display',
'align-self',
'bottom',
'flex-direction',
'flex-wrap',
'font-family',
'font-size',
'font-style',
'font-weight',
'gap',
'height',
'justify-content',
'letter-spacing',
'left',
'line-height',
'max-height',
'max-width',
'min-height',
'min-width',
'object-fit',
'opacity',
'overflow',
'padding-bottom',
'padding-left',
'padding-right',
'padding-top',
'position',
'right',
'row-gap',
'text-align',
'text-decoration-line',
'text-shadow',
'text-transform',
'top',
'white-space',
'width'
] as const
function resolveBrowserDocument(documentOverride: Document | undefined): Document {
if (documentOverride) return documentOverride
if (typeof document === 'undefined') {
throw new TypeError('Browser CSS runtime requires a DOM document')
}
return document
}
function attributesToRecord(element: Element): Record<string, string> {
const attrs: Record<string, string> = {}
for (const attr of Array.from(element.attributes)) {
attrs[attr.name] = attr.value
}
return attrs
}
function styleToRecord(style: CSSStyleDeclaration): Record<string, string> | undefined {
const entries: Record<string, string> = {}
for (const property of Array.from(style)) {
const value = style.getPropertyValue(property)
if (value) entries[property] = value
}
return Object.keys(entries).length > 0 ? entries : undefined
}
const NON_RENDERED_TAGS = new Set(['head', 'link', 'meta', 'script', 'style', 'template', 'title'])
function domNodeToDesignNode(node: Node): DesignNode | null {
if (node.nodeType === 3) {
const text = node.textContent ?? ''
return text.length > 0 ? { type: 'text', text } : null
}
if (node.nodeType !== 1) return null
const element = node as Element
if (NON_RENDERED_TAGS.has(element.tagName.toLowerCase())) return null
const children = Array.from(element.childNodes)
.map(domNodeToDesignNode)
.filter((child): child is DesignNode => child !== null)
const style = 'style' in element ? (element.style as CSSStyleDeclaration) : undefined
return {
type: 'element',
tagName: element.tagName.toLowerCase(),
attrs: attributesToRecord(element),
children,
inlineStyle: style ? styleToRecord(style) : undefined
}
}
function parseHTMLWithDocument(browserDocument: Document, html: string): DesignDocument {
const Parser = browserDocument.defaultView?.DOMParser
if (!Parser) throw new TypeError('Browser CSS runtime requires DOMParser')
const parser = new Parser()
const parsed = parser.parseFromString(html, 'text/html')
return {
type: 'document',
children: Array.from(parsed.body.childNodes)
.map(domNodeToDesignNode)
.filter((node): node is DesignNode => node !== null)
}
}
function collectElementPairs(
designNode: DesignNode,
domNode: Node,
pairs: [DesignElement, Element][]
): void {
if (designNode.type === 'text') return
const view = domNode.ownerDocument?.defaultView
if (!view || !(domNode instanceof view.Element)) return
pairs.push([designNode, domNode])
const elementChildren = designNode.children.filter(
(child): child is DesignElement => child.type === 'element'
)
const domChildren = Array.from(domNode.children)
for (const [index, child] of elementChildren.entries()) {
const domChild = domChildren.at(index)
if (domChild) collectElementPairs(child, domChild, pairs)
}
}
function computedStyleToRecord(
style: CSSStyleDeclaration,
options: CSSComputeOptions
): Record<string, string> {
const entries: Record<string, string> = {}
const properties = options.includeBrowserDefaults
? Array.from(style)
: DEFAULT_COMPUTED_PROPERTIES
for (const property of properties) {
const value = style.getPropertyValue(property)
if (value) entries[property] = value
}
return entries
}
function requestFrame(browserDocument: Document): Promise<void> {
const requestAnimationFrame = browserDocument.defaultView?.requestAnimationFrame
if (!requestAnimationFrame) return Promise.resolve()
return new Promise((resolve) => {
requestAnimationFrame(() => resolve())
})
}
function applySandboxHostStyle(element: HTMLElement): void {
element.style.cssText = [
'position: fixed',
'left: -100000px',
'top: 0',
'width: 1000px',
'height: auto',
'visibility: hidden',
'pointer-events: none',
'contain: layout style paint'
].join(';')
}
async function computeStylesInShadowRoot(
browserDocument: Document,
designDocument: DesignDocument,
cssText: string,
options: CSSComputeOptions
): Promise<DesignDocument> {
const host = browserDocument.createElement('div')
applySandboxHostStyle(host)
const shadow = host.attachShadow({ mode: 'open' })
const style = browserDocument.createElement('style')
style.textContent = cssText
shadow.append(style)
const content = browserDocument.createElement('div')
content.innerHTML = serializeHTML(designDocument)
shadow.append(content)
browserDocument.body.append(host)
try {
await requestFrame(browserDocument)
return copyComputedStyles(designDocument, content, options)
} finally {
host.remove()
}
}
async function computeStylesInIframe(
browserDocument: Document,
designDocument: DesignDocument,
cssText: string,
options: CSSComputeOptions
): Promise<DesignDocument> {
const iframe = browserDocument.createElement('iframe')
applySandboxHostStyle(iframe)
browserDocument.body.append(iframe)
try {
const iframeDocument = iframe.contentDocument
if (!iframeDocument) throw new TypeError('Browser CSS runtime could not create iframe document')
iframeDocument.open()
iframeDocument.write(`<!doctype html><html><head></head><body></body></html>`)
iframeDocument.close()
const style = iframeDocument.createElement('style')
style.textContent = cssText
iframeDocument.head.append(style)
const content = iframeDocument.createElement('div')
content.innerHTML = serializeHTML(designDocument)
iframeDocument.body.append(content)
await requestFrame(iframeDocument)
return copyComputedStyles(designDocument, content, options)
} finally {
iframe.remove()
}
}
function copyComputedStyles(
designDocument: DesignDocument,
content: Element,
options: CSSComputeOptions
): DesignDocument {
const view = content.ownerDocument.defaultView
if (!view) throw new TypeError('Browser CSS runtime requires getComputedStyle')
const nextDocument = structuredClone(designDocument)
const pairs: [DesignElement, Element][] = []
const domChildren = Array.from(content.childNodes)
for (const [index, child] of nextDocument.children.entries()) {
const domChild = domChildren.at(index)
if (domChild) collectElementPairs(child, domChild, pairs)
}
for (const [designElement, domElement] of pairs) {
designElement.computedStyle = computedStyleToRecord(view.getComputedStyle(domElement), options)
}
return nextDocument
}
export function createBrowserCSSRuntime(options: BrowserCSSRuntimeOptions = {}): CSSRuntime {
const browserDocument = resolveBrowserDocument(options.document)
const sandbox = options.sandbox ?? 'shadow-root'
return {
kind: 'browser',
parseHTML: (html) => parseHTMLWithDocument(browserDocument, html),
serializeHTML,
computeStyles: (designDocument, cssText = '', computeOptions = {}) =>
sandbox === 'iframe'
? computeStylesInIframe(browserDocument, designDocument, cssText, computeOptions)
: computeStylesInShadowRoot(browserDocument, designDocument, cssText, computeOptions)
}
}