AI-native design editor. Open-source Figma alternative.
feat(export): persist per-node export settings
rcoenen33f53324f729
diff --git a/packages/core/src/canvas/renderer.ts b/packages/core/src/canvas/renderer.tsindex fc0e990cf..db7aab00b 100644--- a/packages/core/src/canvas/renderer.ts+++ b/packages/core/src/canvas/renderer.ts@@ -618,6 +618,46 @@ export class SkiaRenderer {}}+ /**+ * Browser fallback for raster formats CanvasKit cannot encode itself+ * (this build returns null from `encodeToBytes` for JPEG/WEBP). Routes the+ * RGBA pixels through an HTMLCanvasElement so `toDataURL` does the encoding.+ * Returns null outside the browser or if encoding fails.+ */+ encodeRasterFallback(+ pixels: Uint8Array,+ width: number,+ height: number,+ format: 'JPG' | 'WEBP',+ quality: number+ ): Uint8Array | null {+ if (!IS_BROWSER) return null+ try {+ const canvas = document.createElement('canvas')+ canvas.width = width+ canvas.height = height+ const ctx = canvas.getContext('2d')+ if (!ctx) return null+ const imageData = ctx.createImageData(width, height)+ imageData.data.set(pixels)+ ctx.putImageData(imageData, 0, 0)+ const mime = format === 'JPG' ? 'image/jpeg' : 'image/webp'+ const dataUrl = canvas.toDataURL(mime, quality / 100)+ // Browsers silently return a PNG data URL when the requested encoder is+ // unsupported; reject that so we never write PNG bytes under a .jpg/.webp file.+ if (!dataUrl.startsWith(`data:${mime}`)) return null+ const base64 = dataUrl.split(',')[1]+ if (!base64) return null+ const binary = atob(base64)+ const bytes = new Uint8Array(binary.length)+ for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i)+ return bytes+ } catch (err) {+ console.warn('Raster encode fallback failed:', err)+ return null+ }+ }+destroyed: boolean = falsedestroy(): void {diff --git a/packages/core/src/io/formats/raster/render.ts b/packages/core/src/io/formats/raster/render.tsindex fcc5df463..a9c9efb0c 100644--- a/packages/core/src/io/formats/raster/render.ts+++ b/packages/core/src/io/formats/raster/render.ts@@ -183,10 +183,39 @@ function renderToSurface(]): downsampleSurface.makeImageSnapshot()const encoded = image.encodeToBytes(ckImageFormat(ck, format), quality)+ let resultBytes: Uint8Array | null = encoded ? new Uint8Array(encoded) : null++ // CanvasKit's `encodeToBytes` returns null for JPEG/WEBP in this build, so+ // fall back to encoding the raw pixels through the browser canvas.+ if (!resultBytes && (format === 'JPG' || format === 'WEBP')) {+ const exportWidth = alphaBounds ? alphaBounds.maxX - alphaBounds.minX : width+ const exportHeight = alphaBounds ? alphaBounds.maxY - alphaBounds.minY : height+ const exportMinX = alphaBounds ? alphaBounds.minX : 0+ const exportMinY = alphaBounds ? alphaBounds.minY : 0++ const rawPixels = downsampleCanvas.readPixels(exportMinX, exportMinY, {+ alphaType: ck.AlphaType.Unpremul,+ colorType: ck.ColorType.RGBA_8888,+ colorSpace: ck.ColorSpace.SRGB,+ width: exportWidth,+ height: exportHeight+ })++ if (rawPixels instanceof Uint8Array) {+ resultBytes = renderer.encodeRasterFallback(+ rawPixels,+ exportWidth,+ exportHeight,+ format,+ quality+ )+ }+ }+image.delete()downsampleSurface.delete()ck.Free(downsamplePixels)- return encoded ? new Uint8Array(encoded) : null+ return resultBytes} finally {surface.delete()ck.Free(pixels)diff --git a/packages/core/src/kiwi/fig/node-change/convert.ts b/packages/core/src/kiwi/fig/node-change/convert.tsindex ce75b8b2f..c22e0dee4 100644--- a/packages/core/src/kiwi/fig/node-change/convert.ts+++ b/packages/core/src/kiwi/fig/node-change/convert.ts@@ -15,6 +15,7 @@ export { convertEffects, convertFills, convertStrokes, setVariableColorResolverexport { convertLetterSpacing, convertLineHeight, mapTextDecoration } from './text-values'import {extractBoundVariables,+ extractExportSettings,extractPluginData,extractPluginRelaunchData,getOpenPencilPluginValue,@@ -563,6 +564,7 @@ export function nodeChangeToProps(expanded: true,autoRename: (nc.autoRename ?? true) as boolean,boundVariables: extractBoundVariables(nc),+ exportSettings: extractExportSettings(nc),pluginData: extractPluginData(nc),pluginRelaunchData: extractPluginRelaunchData(nc),clipsContent: nc.frameMaskDisabled === false && nc.resizeToFit !== true,diff --git a/packages/core/src/kiwi/fig/node-change/export-node.ts b/packages/core/src/kiwi/fig/node-change/export-node.tsindex cc375e0db..b5e7e94d8 100644--- a/packages/core/src/kiwi/fig/node-change/export-node.ts+++ b/packages/core/src/kiwi/fig/node-change/export-node.ts@@ -6,6 +6,7 @@ import type { Color, GUID, Matrix, Vector } from '#core/types'import { stringToGuid } from './guid'import {+ applyExportSettingsPluginData,mergePluginData,NODE_TYPE_PLUGIN_KEY,serializePluginRelaunchData,@@ -691,6 +692,7 @@ export function sceneNodeToKiwiWithContext(context.serializeVariableBindings(node, nc, context.graph, context.varIdToGuid)applyRawFigmaNodeFields(context, node, nc)+ applyExportSettingsPluginData(node)const pluginData = mergePluginData(node.pluginData)if (pluginData.length > 0) nc.pluginData = pluginDataif (node.pluginRelaunchData.length > 0) {diff --git a/packages/core/src/kiwi/fig/node-change/plugin-data.ts b/packages/core/src/kiwi/fig/node-change/plugin-data.tsindex 16c2f60fa..db9b0cba6 100644--- a/packages/core/src/kiwi/fig/node-change/plugin-data.ts+++ b/packages/core/src/kiwi/fig/node-change/plugin-data.ts@@ -1,5 +1,11 @@import type { NodeChange, PluginData, PluginRelaunchData } from '#core/kiwi/fig/codec'-import type { PluginDataEntry, PluginRelaunchDataEntry } from '#core/scene-graph'+import { clampExportScale } from '#core/scene-graph'+import type {+ ExportFormatId,+ ExportSetting,+ PluginDataEntry,+ PluginRelaunchDataEntry+} from '#core/scene-graph'import { guidToString } from './guid'@@ -8,6 +14,14 @@ export const TEXT_DIRECTION_PLUGIN_KEY = 'textDirection'export const LAYOUT_DIRECTION_PLUGIN_KEY = 'layoutDirection'export const NODE_TYPE_PLUGIN_KEY = 'nodeType'export const BOUND_VARIABLES_PLUGIN_KEY = 'boundVariables'+export const EXPORT_SETTINGS_PLUGIN_KEY = 'exportSettings'++const NATIVE_EXPORT_FORMATS: Record<string, ExportFormatId> = {+ PNG: 'png',+ JPEG: 'jpg',+ SVG: 'svg',+ PDF: 'pdf'+}export function upsertPluginData(node: { pluginData: PluginDataEntry[] },@@ -21,6 +35,27 @@ export function upsertPluginData(node.pluginData = pluginData}+export function applyExportSettingsPluginData(node: {+ exportSettings: ExportSetting[]+ pluginData: PluginDataEntry[]+ source?: { fig?: { rawNodeFields?: Record<string, unknown> } }+}): void {+ if (node.exportSettings.length === 0) return+ if (+ !hasOpenPencilExportSettingsPluginData(node.pluginData) &&+ Array.isArray(node.source?.fig?.rawNodeFields?.exportSettings)+ ) {+ return+ }+ upsertPluginData(node, EXPORT_SETTINGS_PLUGIN_KEY, JSON.stringify(node.exportSettings))+}++function hasOpenPencilExportSettingsPluginData(pluginData: PluginDataEntry[]): boolean {+ return pluginData.some(+ (entry) => entry.pluginId === OPEN_PENCIL_PLUGIN_ID && entry.key === EXPORT_SETTINGS_PLUGIN_KEY+ )+}+function parseBoundVariablesPluginValue(value: string | null): Record<string, string> {if (!value) return {}try {@@ -54,6 +89,71 @@ export function extractBoundVariables(nc: NodeChange): Record<string, string> {return bindings}+function isExportFormatId(value: unknown): value is ExportFormatId {+ return (+ value === 'png' || value === 'jpg' || value === 'webp' || value === 'svg' || value === 'pdf'+ )+}++function parseExportSettingsPluginValue(value: string | null): ExportSetting[] | null {+ if (!value) return null+ try {+ const parsed = JSON.parse(value) as unknown+ if (!Array.isArray(parsed)) return null+ const settings = parsed.flatMap((entry): ExportSetting[] => {+ if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return []+ const scale = (entry as { scale?: unknown }).scale+ const format = (entry as { format?: unknown }).format+ if (typeof scale !== 'number' || !Number.isFinite(scale) || !isExportFormatId(format)) {+ return []+ }+ // Clamp at the file-format boundary: imported plugin data may carry an+ // out-of-range scale the UI would never produce.+ return [{ scale: clampExportScale(scale), format }]+ })+ return settings.length === parsed.length ? settings : null+ } catch {+ return null+ }+}++function mapNativeImageType(imageType: unknown): ExportFormatId | null {+ if (typeof imageType === 'string') return NATIVE_EXPORT_FORMATS[imageType] ?? null+ if (imageType === 0) return 'png'+ if (imageType === 1) return 'jpg'+ if (imageType === 2) return 'svg'+ if (imageType === 3) return 'pdf'+ return null+}++function extractNativeConstraintScale(constraint: unknown): number {+ if (!constraint || typeof constraint !== 'object' || Array.isArray(constraint)) return 1+ const type = (constraint as { type?: unknown }).type+ if (type !== 'CONTENT_SCALE' && type !== 0) return 1+ const value = (constraint as { value?: unknown }).value+ // Clamp native CONTENT_SCALE too: malformed .fig data can carry huge multipliers.+ return typeof value === 'number' && Number.isFinite(value) ? clampExportScale(value) : 1+}++export function extractExportSettings(nc: NodeChange): ExportSetting[] {+ const pluginSettings = parseExportSettingsPluginValue(+ getOpenPencilPluginValue(nc, EXPORT_SETTINGS_PLUGIN_KEY)+ )+ if (pluginSettings) return pluginSettings++ return (nc.exportSettings ?? []).flatMap((entry): ExportSetting[] => {+ if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return []+ const format = mapNativeImageType((entry as { imageType?: unknown }).imageType)+ if (!format) return []+ return [+ {+ scale: extractNativeConstraintScale((entry as { constraint?: unknown }).constraint),+ format+ }+ ]+ })+}+export function extractPluginData(nc: NodeChange): PluginDataEntry[] {return (nc.pluginData ?? []).map((entry) => ({pluginId: entry.pluginID,diff --git a/packages/core/src/scene-graph/export-scale.ts b/packages/core/src/scene-graph/export-scale.tsnew file mode 100644index 000000000..97e475ae3--- /dev/null+++ b/packages/core/src/scene-graph/export-scale.ts@@ -0,0 +1,16 @@+/**+ * Bounds for export scale multipliers. A huge multiplier would allocate an+ * enormous canvas and crash the renderer, so clamp at every boundary the value+ * can enter from: the UI (edits) and the file format (imported/plugin .fig data).+ */+export const MIN_EXPORT_SCALE = 0.01+export const MAX_EXPORT_SCALE = 1024++export function clampExportScale(scale: number): number {+ return Math.min(MAX_EXPORT_SCALE, Math.max(MIN_EXPORT_SCALE, scale))+}++/** Accept a scale only if it is finite and within bounds (no silent clamping). */+export function isValidExportScale(scale: number): boolean {+ return Number.isFinite(scale) && scale >= MIN_EXPORT_SCALE && scale <= MAX_EXPORT_SCALE+}diff --git a/packages/core/src/scene-graph/index.ts b/packages/core/src/scene-graph/index.tsindex 44527c8ea..e63acdde1 100644--- a/packages/core/src/scene-graph/index.ts+++ b/packages/core/src/scene-graph/index.ts@@ -1,4 +1,5 @@export * from './snap'+export * from './export-scale'export { UndoManager, type UndoEntry, type UndoManagerOptions } from './undo'import { createNanoEvents } from 'nanoevents'diff --git a/packages/core/src/scene-graph/node-defaults.ts b/packages/core/src/scene-graph/node-defaults.tsindex 4715d1d56..56fde04ac 100644--- a/packages/core/src/scene-graph/node-defaults.ts+++ b/packages/core/src/scene-graph/node-defaults.ts@@ -141,6 +141,7 @@ export function createDefaultNode(symbolLinks: [],variantPropSpecs: [],boundVariables: {},+ exportSettings: [],pluginData: [],pluginRelaunchData: [],internalOnly: false,diff --git a/packages/core/src/scene-graph/source-metadata.ts b/packages/core/src/scene-graph/source-metadata.tsindex 4f7df88cd..cf27dc9dc 100644--- a/packages/core/src/scene-graph/source-metadata.ts+++ b/packages/core/src/scene-graph/source-metadata.ts@@ -80,4 +80,10 @@ export function clearEditedSourceMetadata(node: SceneNode, changeKeys: string[])if (changeKeys.some((key) => RAW_SIZE_KEYS.has(key))) node.source.fig.rawSize = nullif (changeKeys.some((key) => RAW_TRANSFORM_KEYS.has(key))) node.source.fig.rawTransform = nullif (changeKeys.some((key) => RAW_NODE_FIELD_KEYS.has(key))) node.source.fig.rawNodeFields = {}+ // Export settings are persisted via plugin data, not RAW_NODE_FIELD_KEYS. Once the+ // user edits them (including clearing every row) drop the raw native exportSettings+ // so they don't resurrect from the import fallback (extractExportSettings) on reopen.+ if (changeKeys.includes('exportSettings')) {+ delete node.source.fig.rawNodeFields.exportSettings+ }}diff --git a/packages/core/src/scene-graph/types.ts b/packages/core/src/scene-graph/types.tsindex c1d954768..74162582a 100644--- a/packages/core/src/scene-graph/types.ts+++ b/packages/core/src/scene-graph/types.ts@@ -260,6 +260,13 @@ export interface PluginDataEntry {value: string}+export type ExportFormatId = 'png' | 'jpg' | 'webp' | 'svg' | 'pdf'++export interface ExportSetting {+ scale: number+ format: ExportFormatId+}+export interface PluginRelaunchDataEntry {pluginId: stringcommand: string@@ -455,6 +462,7 @@ export interface SceneNode {variantPropSpecs: VariantPropSpec[]boundVariables: Record<string, string>+ exportSettings: ExportSetting[]pluginData: PluginDataEntry[]pluginRelaunchData: PluginRelaunchDataEntry[]diff --git a/packages/vue/src/document/export/helpers.ts b/packages/vue/src/document/export/helpers.tsindex ec8528a14..bd5530fca 100644--- a/packages/vue/src/document/export/helpers.ts+++ b/packages/vue/src/document/export/helpers.ts@@ -1,13 +1,24 @@import { computed } from 'vue'-import type { Ref } from 'vue'+import type { ComputedRef } from 'vue'import type { Editor } from '@open-pencil/core/editor'import { BUILTIN_IO_FORMATS, IORegistry } from '@open-pencil/core/io'+import { MAX_EXPORT_SCALE, MIN_EXPORT_SCALE, clampExportScale } from '@open-pencil/core/scene-graph'+import type { ExportFormatId, ExportSetting, PluginDataEntry } from '@open-pencil/core/scene-graph'-import type { ExportFormatId, ExportPanelTarget, ExportSetting } from '#vue/document/export/use'+import { useSceneComputed } from '#vue/internal/scene-computed/use'export const EXPORT_SCALES = [0.5, 0.75, 1, 1.5, 2, 3, 4] as const-export const EXPORT_FORMATS: ExportFormatId[] = ['png', 'jpg', 'webp', 'svg', 'pdf', 'fig']+export const EXPORT_FORMATS: ExportFormatId[] = ['png', 'jpg', 'webp', 'svg', 'pdf']++export type ExportPanelTarget = 'selection' | 'page'++const OPEN_PENCIL_PLUGIN_ID = 'open-pencil'+const EXPORT_SETTINGS_PLUGIN_KEY = 'exportSettings'++// Re-exported from core so the UI and the .fig file-format boundary share one+// definition of the export-scale bounds (see scene-graph/export-scale).+export { MIN_EXPORT_SCALE, MAX_EXPORT_SCALE, clampExportScale }const io = new IORegistry(BUILTIN_IO_FORMATS)@@ -19,16 +30,14 @@ export function formatSupportsScale(format: ExportFormatId) {return io.getFormat(format)?.exportOptions?.scale ?? false}-export function createExportTargetState(- editor: Editor,- selectedIds: Ref<string[]>,- selectionSettings: Ref<ExportSetting[]>,- pageSettings: Ref<ExportSetting[]>-) {+export function createExportTargetState(editor: Editor, selectedIds: ComputedRef<string[]>) {const hasSelection = computed(() => selectedIds.value.length > 0)const activeTarget = computed<ExportPanelTarget>(() =>hasSelection.value ? 'selection' : 'page')+ const targetIds = useSceneComputed(() =>+ selectedIds.value.length > 0 ? selectedIds.value : [editor.state.currentPageId]+ )const selectedNodeName = computed(() => {const ids = editor.state.selectedIds@@ -50,49 +59,132 @@ export function createExportTargetState(? (selectedNodeName.value ?? 'Export'): currentPageName.value)- const activeSettings = computed(() =>- activeTarget.value === 'selection' ? selectionSettings.value : pageSettings.value- )+ const activeSettings = useSceneComputed(() => {+ const firstId = targetIds.value[0]+ return firstId ? [...(editor.graph.getNode(firstId)?.exportSettings ?? [])] : []+ })+ const mixed = useSceneComputed(() => {+ const [firstId, ...otherIds] = targetIds.value+ if (!firstId || otherIds.length === 0) return false+ const first = editor.graph.getNode(firstId)?.exportSettings ?? []+ return otherIds.some((id) => {+ const settings = editor.graph.getNode(id)?.exportSettings ?? []+ return !exportSettingsEqual(first, settings)+ })+ })return {hasSelection,activeTarget,+ targetIds,selectedNodeName,currentPageName,activeName,- activeSettings+ activeSettings,+ mixed}}-export function createExportSettingActions(- selectionSettings: Ref<ExportSetting[]>,- pageSettings: Ref<ExportSetting[]>+function exportSettingsEqual(a: ExportSetting[], b: ExportSetting[]) {+ if (a.length !== b.length) return false+ return a.every((setting, index) => {+ const other = b[index]+ return setting.scale === other.scale && setting.format === other.format+ })+}++function nextExportSetting(settings: ExportSetting[]): ExportSetting {+ const last = settings.at(-1)+ if (!last) return createDefaultExportSetting()+ // Each added row doubles the previous scale (1x → 2x → 4x …).+ return {+ scale: clampExportScale(last.scale * 2),+ format: last.format+ }+}++function syncExportSettingsPluginData(+ pluginData: PluginDataEntry[],+ settings: ExportSetting[]+): PluginDataEntry[] {+ const withoutExportSettings = pluginData.filter(+ (entry) =>+ !(entry.pluginId === OPEN_PENCIL_PLUGIN_ID && entry.key === EXPORT_SETTINGS_PLUGIN_KEY)+ )+ if (settings.length === 0) return withoutExportSettings+ return [+ ...withoutExportSettings,+ {+ pluginId: OPEN_PENCIL_PLUGIN_ID,+ key: EXPORT_SETTINGS_PLUGIN_KEY,+ value: JSON.stringify(settings)+ }+ ]+}++function updateEveryTarget(+ editor: Editor,+ targetIds: ComputedRef<string[]>,+ label: string,+ update: (settings: ExportSetting[]) => ExportSetting[]) {- function addSetting(settings: Ref<ExportSetting[]>) {- const last = settings.value[settings.value.length - 1]- const nextScale = EXPORT_SCALES.find((s) => s > last.scale) ?? 2- settings.value.push({ scale: nextScale, format: last.format })+ editor.undo.runBatch(label, () => {+ for (const id of targetIds.value) {+ const node = editor.graph.getNode(id)+ if (!node) continue+ const exportSettings = update(node.exportSettings)+ editor.updateNodeWithUndo(+ id,+ {+ exportSettings,+ pluginData: syncExportSettingsPluginData(node.pluginData, exportSettings)+ },+ label+ )+ }+ })+}++export function createExportSettingActions(editor: Editor, targetIds: ComputedRef<string[]>) {+ function addSetting() {+ updateEveryTarget(editor, targetIds, 'Add export setting', (settings) => [+ ...settings,+ nextExportSetting(settings)+ ])+ }++ function removeSetting(index: number) {+ updateEveryTarget(editor, targetIds, 'Remove export setting', (settings) =>+ settings.filter((_, i) => i !== index)+ )}- function updateScale(settings: Ref<ExportSetting[]>, index: number, scale: number) {- settings.value[index] = { ...settings.value[index], scale }+ function updateScale(index: number, scale: number) {+ updateEveryTarget(editor, targetIds, 'Update export scale', (settings) =>+ settings.map((setting, i) =>+ i === index ? { ...setting, scale: clampExportScale(scale) } : setting+ )+ )}- function updateFormat(settings: Ref<ExportSetting[]>, index: number, format: ExportFormatId) {- settings.value[index] = { ...settings.value[index], format }+ function updateFormat(index: number, format: ExportFormatId) {+ updateEveryTarget(editor, targetIds, 'Update export format', (settings) =>+ settings.map((setting, i) => (i === index ? { ...setting, format } : setting))+ )}return {- addSelectionSetting: () => addSetting(selectionSettings),- addPageSetting: () => addSetting(pageSettings),- removeSelectionSetting: (index: number) => selectionSettings.value.splice(index, 1),- removePageSetting: (index: number) => pageSettings.value.splice(index, 1),- updateSelectionScale: (index: number, scale: number) =>- updateScale(selectionSettings, index, scale),- updatePageScale: (index: number, scale: number) => updateScale(pageSettings, index, scale),- updateSelectionFormat: (index: number, format: ExportFormatId) =>- updateFormat(selectionSettings, index, format),- updatePageFormat: (index: number, format: ExportFormatId) =>- updateFormat(pageSettings, index, format)+ addSetting,+ removeSetting,+ updateScale,+ updateFormat,+ addSelectionSetting: addSetting,+ addPageSetting: addSetting,+ removeSelectionSetting: removeSetting,+ removePageSetting: removeSetting,+ updateSelectionScale: updateScale,+ updatePageScale: updateScale,+ updateSelectionFormat: updateFormat,+ updatePageFormat: updateFormat}}diff --git a/packages/vue/src/document/export/use.ts b/packages/vue/src/document/export/use.tsindex 85407eb71..9b26f24f7 100644--- a/packages/vue/src/document/export/use.ts+++ b/packages/vue/src/document/export/use.ts@@ -1,9 +1,9 @@-import { ref } from 'vue'-import {EXPORT_FORMATS,EXPORT_SCALES,- createDefaultExportSetting,+ MAX_EXPORT_SCALE,+ MIN_EXPORT_SCALE,+ clampExportScale,createExportSettingActions,createExportTargetState,formatSupportsScale@@ -11,32 +11,26 @@ import {import { useEditor } from '#vue/editor/context'import { useSceneComputed } from '#vue/internal/scene-computed/use'-export type ExportFormatId = 'png' | 'jpg' | 'webp' | 'svg' | 'pdf' | 'fig'-export type ExportPanelTarget = 'selection' | 'page'--export interface ExportSetting {- scale: number- format: ExportFormatId-}+export type { ExportFormatId, ExportSetting } from '@open-pencil/core/scene-graph'+export type { ExportPanelTarget } from '#vue/document/export/helpers'export function useExport() {const editor = useEditor()- const selectionSettings = ref<ExportSetting[]>([createDefaultExportSetting()])- const pageSettings = ref<ExportSetting[]>([createDefaultExportSetting()])const selectedIds = useSceneComputed(() => [...editor.state.selectedIds])- const targetState = createExportTargetState(editor, selectedIds, selectionSettings, pageSettings)- const settingActions = createExportSettingActions(selectionSettings, pageSettings)+ const targetState = createExportTargetState(editor, selectedIds)+ const settingActions = createExportSettingActions(editor, targetState.targetIds)return {editor,selectedIds,scales: EXPORT_SCALES,+ maxScale: MAX_EXPORT_SCALE,+ minScale: MIN_EXPORT_SCALE,+ clampExportScale,formats: EXPORT_FORMATS,formatSupportsScale,- selectionSettings,- pageSettings,...targetState,...settingActions}diff --git a/packages/vue/src/index.ts b/packages/vue/src/index.tsindex a95948863..b1fc96051 100644--- a/packages/vue/src/index.ts+++ b/packages/vue/src/index.ts@@ -78,7 +78,7 @@ export { useAppearance } from '#vue/controls/appearance/use'export { useTypography } from '#vue/controls/typography/use'export type { UseTypographyOptions } from '#vue/controls/typography/use'export { useExport } from '#vue/document/export/use'-export type { ExportFormatId } from '#vue/document/export/use'+export type { ExportFormatId, ExportSetting } from '#vue/document/export/use'export { useFillControls } from '#vue/controls/fill/use'export { useColorVariableBinding } from '#vue/controls/color-variable-binding/use'export { useNumberVariableBinding } from '#vue/controls/number-variable-binding/use'diff --git a/src/app/document/export/create.ts b/src/app/document/export/create.tsindex e8e410b07..90e75fea6 100644--- a/src/app/document/export/create.ts+++ b/src/app/document/export/create.ts@@ -2,17 +2,25 @@ import type { Editor, EditorState } from '@open-pencil/core/editor'import type { ExportRequest, IORegistry } from '@open-pencil/core/io'import {+ bundleExportFiles,createExportTargetActions,getExportBaseName,getExportBytes,getExportFileName,getExportOptions,- saveExportedFile+ saveExportedFile,+ type ExportedFile} from '@/app/document/export/files'import type { ExportOptions } from '@/app/document/export/types'type DownloadBlob = (data: Uint8Array, filename: string, mime: string) => void+export interface ExportTargetRequest {+ target: ExportRequest['target']+ formatId: string+ options?: ExportOptions+}+export function createDocumentExportActions(editor: Editor,state: EditorState,@@ -22,11 +30,11 @@ export function createDocumentExportActions(const { renderExportImage, getSelectionExportTarget, listSelectionExportFormats } =createExportTargetActions(editor, state, io)- async function exportTarget(+ async function renderExportFile(target: ExportRequest['target'],formatId: string,options?: ExportOptions- ) {+ ): Promise<ExportedFile> {const format = io.getFormat(formatId)if (!format) throw new Error(`Unknown export format: ${formatId}`)@@ -40,15 +48,57 @@ export function createDocumentExportActions()const baseName = getExportBaseName(editor.graph, target)- const fileName = getExportFileName(baseName, formatId, result.extension, options)- const bytes = getExportBytes(result.data)+ return {+ bytes: getExportBytes(result.data),+ fileName: getExportFileName(baseName, formatId, result.extension, options),+ format: format.label,+ ext: `.${result.extension}`,+ mime: result.mimeType+ }+ }++ async function saveExportFile(file: ExportedFile) {+ await saveExportedFile(+ file.bytes,+ file.fileName,+ file.format,+ file.ext,+ file.mime,+ downloadBlob+ )+ }++ async function exportTarget(+ target: ExportRequest['target'],+ formatId: string,+ options?: ExportOptions+ ) {+ await saveExportFile(await renderExportFile(target, formatId, options))+ }++ // Export a batch of targets. A single file downloads directly; multiple files+ // are bundled into one zip so the user gets a single download.+ async function exportTargets(requests: ExportTargetRequest[]) {+ if (requests.length === 0) return++ const files: ExportedFile[] = []+ for (const request of requests) {+ files.push(await renderExportFile(request.target, request.formatId, request.options))+ }++ if (files.length === 1) {+ await saveExportFile(files[0])+ return+ }+ const baseNames = new Set(requests.map((r) => getExportBaseName(editor.graph, r.target)))+ const zipBaseName = baseNames.size === 1 ? [...baseNames][0] : 'export'await saveExportedFile(- bytes,- fileName,- format.label,- `.${result.extension}`,- result.mimeType,+ bundleExportFiles(files),+ `${zipBaseName}.zip`,+ 'ZIP',+ '.zip',+ 'application/zip',downloadBlob)}@@ -64,6 +114,7 @@ export function createDocumentExportActions(renderExportImage,listSelectionExportFormats,exportTarget,+ exportTargets,exportSelection}}diff --git a/src/app/document/export/files.ts b/src/app/document/export/files.tsindex 84e6198c0..a6f3ce99b 100644--- a/src/app/document/export/files.ts+++ b/src/app/document/export/files.ts@@ -1,3 +1,5 @@+import { zipSync, type Zippable } from 'fflate'+import type { Editor, EditorState } from '@open-pencil/core/editor'import type {ExportRequest,@@ -15,6 +17,53 @@ type ExportData = string | ArrayBuffer | Uint8Arraytype DownloadBlob = (data: Uint8Array, filename: string, mime: string) => void+export interface ExportedFile {+ bytes: Uint8Array+ fileName: string+ format: string+ ext: string+ mime: string+}++// Layer/page names flow into zip entry keys; flatten them to a single safe+// segment so separators, parent refs (`..`), or control chars can't escape the+// archive or corrupt it.+function sanitizeZipEntryName(name: string): string {+ const withoutControl = Array.from(name)+ .filter((ch) => {+ const code = ch.charCodeAt(0)+ return code >= 0x20 && code !== 0x7f+ })+ .join('')+ const flat = withoutControl+ .replace(/[/\\]+/g, '_') // path separators+ .replace(/\.{2,}/g, '_') // parent-dir refs / repeated dots+ .replace(/^[.\s]+/, '') // leading dots / whitespace+ .trim()+ return flat.length > 0 ? flat : 'export'+}++// Bundle several exported files into a single zip, disambiguating any+// duplicate file names (e.g. two layers both producing "[email protected]").+export function bundleExportFiles(files: ExportedFile[]): Uint8Array {+ const entries: Zippable = {}+ const used = new Set<string>()+ for (const file of files) {+ let name = sanitizeZipEntryName(file.fileName)+ if (used.has(name)) {+ const dot = name.lastIndexOf('.')+ const stem = dot === -1 ? name : name.slice(0, dot)+ const tail = dot === -1 ? '' : name.slice(dot)+ let i = 2+ while (used.has(`${stem} (${i})${tail}`)) i+++ name = `${stem} (${i})${tail}`+ }+ used.add(name)+ entries[name] = file.bytes+ }+ return zipSync(entries)+}+export function getExportBaseName(graph: SceneGraph, target: ExportRequest['target']): string {if (target.scope === 'node') return graph.getNode(target.nodeId)?.name ?? 'Export'if (target.scope === 'selection' && target.nodeIds.length === 1) {diff --git a/src/components/DesignPanel.vue b/src/components/DesignPanel.vueindex 2655faa64..5cca918cc 100644--- a/src/components/DesignPanel.vue+++ b/src/components/DesignPanel.vue@@ -54,6 +54,7 @@ const { panels } = useI18n()<FillSection /><StrokeSection /><EffectsSection />+ <ExportSection /></div><!-- Single selection -->diff --git a/src/components/properties/ExportScaleInput.vue b/src/components/properties/ExportScaleInput.vuenew file mode 100644index 000000000..9f648a6fd--- /dev/null+++ b/src/components/properties/ExportScaleInput.vue@@ -0,0 +1,103 @@+<script setup lang="ts">+import { ref, watch } from 'vue'+import {+ DropdownMenuContent,+ DropdownMenuItem,+ DropdownMenuPortal,+ DropdownMenuRoot,+ DropdownMenuTrigger+} from 'reka-ui'++import { vTestId, type TestIdProps } from '@open-pencil/vue'++import { useInputUI } from '@/components/ui/input'+import { menuItem, useMenuUI } from '@/components/ui/menu'++interface ExportScaleInputProps extends TestIdProps {+ presets: readonly number[]+ clamp: (scale: number) => number+ label?: string+}++const {+ presets,+ clamp,+ label,+ testId = 'export-scale-input'+} = defineProps<ExportScaleInputProps>()++const modelValue = defineModel<number>({ required: true })++const open = ref(false)+const inputRef = ref<HTMLInputElement | null>(null)+const text = ref('')++// Keep the editable text in sync with the committed scale (e.g. 1.5 -> "1.5x").+watch(modelValue, (value) => (text.value = `${value}x`), { immediate: true })++const inputClass = useInputUI({ size: 'sm', ui: { base: 'min-w-0 flex-1' } }).base+const menuCls = useMenuUI({ content: 'min-w-[7rem]' })+const itemCls = menuItem({ justify: 'between' })++function commit() {+ const parsed = Number.parseFloat(text.value.replace(/[^0-9.]/g, ''))+ if (Number.isFinite(parsed) && parsed > 0) modelValue.value = clamp(parsed)+ // Reformat from the resulting value: normalizes "9" -> "9x", reverts invalid+ // input, and reflects clamping (e.g. "9999999" -> "1024x").+ text.value = `${modelValue.value}x`+}++function pick(scale: number) {+ modelValue.value = scale+ open.value = false+}++function isActive(scale: number) {+ return Math.abs(modelValue.value - scale) < 1e-9+}+</script>++<template>+ <div class="flex min-w-0 flex-1 items-center gap-1">+ <input+ ref="inputRef"+ v-model="text"+ v-test-id="testId"+ type="text"+ :title="label"+ :class="inputClass"+ autocomplete="off"+ autocorrect="off"+ autocapitalize="off"+ spellcheck="false"+ @focus="inputRef?.select()"+ @blur="commit"+ @keydown.enter.prevent="inputRef?.blur()"+ @keydown.escape.prevent="((text = `${modelValue}x`), inputRef?.blur())"+ />+ <DropdownMenuRoot v-model:open="open">+ <DropdownMenuTrigger as-child>+ <button+ type="button"+ :title="label"+ class="flex shrink-0 cursor-pointer items-center rounded border border-border bg-input px-1 py-1 text-surface hover:bg-hover"+ >+ <icon-lucide-chevron-down class="size-3 text-muted" />+ </button>+ </DropdownMenuTrigger>+ <DropdownMenuPortal>+ <DropdownMenuContent side="bottom" align="end" :side-offset="4" :class="menuCls.content">+ <DropdownMenuItem+ v-for="scale in presets"+ :key="scale"+ :class="itemCls"+ @select="pick(scale)"+ >+ <span>{{ scale }}x</span>+ <icon-lucide-check v-if="isActive(scale)" class="size-3 text-accent" />+ </DropdownMenuItem>+ </DropdownMenuContent>+ </DropdownMenuPortal>+ </DropdownMenuRoot>+ </div>+</template>diff --git a/src/components/properties/ExportSection.vue b/src/components/properties/ExportSection.vueindex 6f040d074..23ea57567 100644--- a/src/components/properties/ExportSection.vue+++ b/src/components/properties/ExportSection.vue@@ -2,6 +2,7 @@import { ref, computed, watch, onScopeDispose } from 'vue'import AppSelect from '@/components/ui/AppSelect.vue'+import ExportScaleInput from '@/components/properties/ExportScaleInput.vue'import Tip from '@/components/ui/Tip.vue'import { useIconButtonUI } from '@/components/ui/icon-button'import { useSectionUI } from '@/components/ui/section'@@ -17,24 +18,23 @@ const {activeTarget,activeName,activeSettings,- addSelectionSetting,- addPageSetting,- removeSelectionSetting,- removePageSetting,- updateSelectionScale,- updatePageScale,- updateSelectionFormat,- updatePageFormat,- formatSupportsScale+ targetIds,+ mixed,+ addSetting,+ removeSetting,+ updateScale,+ updateFormat,+ formatSupportsScale,+ scales,+ clampExportScale} = useExport()-const SCALE_OPTIONS = [0.5, 0.75, 1, 1.5, 2, 3, 4].map((s) => ({ value: s, label: `${s}x` }))const FORMAT_OPTIONS: { value: ExportFormatId; label: string }[] = [{ value: 'png', label: 'PNG' },{ value: 'jpg', label: 'JPG' },{ value: 'webp', label: 'WEBP' },{ value: 'svg', label: 'SVG' },- { value: 'fig', label: '.fig' }+ { value: 'pdf', label: 'PDF' }]const previewUrl = ref<string | null>(null)@@ -43,41 +43,26 @@ const exporting = ref(false)const PREVIEW_WIDTH = 480-function addSetting() {- if (activeTarget.value === 'selection') addSelectionSetting()- else addPageSetting()-}--function removeSetting(index: number) {- if (activeTarget.value === 'selection') removeSelectionSetting(index)- else removePageSetting(index)-}--function updateScale(index: number, scale: number) {- if (activeTarget.value === 'selection') updateSelectionScale(index, scale)- else updatePageScale(index, scale)-}--function updateFormat(index: number, format: ExportFormatId) {- if (activeTarget.value === 'selection') updateSelectionFormat(index, format)- else updatePageFormat(index, format)-}-async function doExport() {exporting.value = truetry {- if (activeTarget.value === 'selection') {- for (const s of activeSettings.value) await editorStore.exportSelection(s.scale, s.format)- return- }-- for (const s of activeSettings.value) {- await editorStore.exportTarget(- { scope: 'page', pageId: editorStore.state.currentPageId },- s.format,- { scale: s.scale }- )+ const requests = []+ // Export exactly the rows shown in the panel (activeSettings) for every target,+ // so a multi-selection exports what the user sees rather than each node's own+ // (possibly hidden / divergent) settings.+ for (const id of targetIds.value) {+ const node = editorStore.graph.getNode(id)+ if (!node) continue+ const target =+ activeTarget.value === 'page'+ ? ({ scope: 'page', pageId: id } as const)+ : ({ scope: 'node', nodeId: id } as const)+ for (const setting of activeSettings.value) {+ requests.push({ target, formatId: setting.format, options: { scale: setting.scale } })+ }}+ // A single file downloads directly; multiple files bundle into one zip.+ await editorStore.exportTargets(requests)} finally {exporting.value = false}@@ -142,20 +127,24 @@ onScopeDispose(() => {</button></Tip></div>+ <p v-if="mixed" class="text-[11px] text-muted">+ {{ panels.mixed }}+ </p><divv-for="(setting, i) in activeSettings"- :key="`${activeTarget}:${i}`"+ :key="`${targetIds.join(',')}:${i}`"data-test-id="export-item":data-test-index="i"class="flex items-center gap-1.5 py-0.5">- <AppSelect+ <ExportScaleInputv-if="formatSupportsScale(setting.format)":model-value="setting.scale"- :options="SCALE_OPTIONS"+ :presets="scales"+ :clamp="clampExportScale":label="panels.exportScale"- @update:model-value="updateScale(i, Number($event))"+ @update:model-value="updateScale(i, $event)"/><AppSelect:model-value="setting.format"diff --git a/tests/e2e/export/basic.spec.ts b/tests/e2e/export/basic.spec.tsindex ad1e7bf8d..2add06c82 100644--- a/tests/e2e/export/basic.spec.ts+++ b/tests/e2e/export/basic.spec.ts@@ -10,6 +10,7 @@ test.describe.configure({ mode: 'serial' })test.beforeAll(async ({ browser }) => {page = await browser.newPage()+ await page.setViewportSize({ width: 1440, height: 1100 })await page.goto('/')canvas = new CanvasHelper(page)await canvas.waitForInit()@@ -25,6 +26,57 @@ function exportItems() {return page.getByTestId('export-item')}+function exportButton() {+ return page.getByTestId('export-button')+}++async function createRectangles(count: number, settings: unknown[][] = []) {+ const ids = await page.evaluate(+ ({ count: nodeCount, settingsByNode }) => {+ const store = window.openPencil?.getStore?.()+ if (!store) throw new Error('OpenPencil store not initialized')+ for (const node of store.graph.getChildren(store.state.currentPageId)) {+ store.graph.deleteNode(node.id)+ }+ const ids: string[] = []+ for (let i = 0; i < nodeCount; i++) {+ const node = store.graph.createNode('RECTANGLE', store.state.currentPageId, {+ name: `Export rect ${i + 1}`,+ x: 100 + i * 140,+ y: 100,+ width: 100,+ height: 100,+ exportSettings: settingsByNode[i] ?? []+ })+ ids.push(node.id)+ }+ store.select(ids)+ store.requestRender()+ return ids+ },+ { count, settingsByNode: settings }+ )+ await canvas.waitForRender()+ return ids+}++async function selectedExportSettings() {+ return page.evaluate(() => {+ const store = window.openPencil?.getStore?.()+ if (!store) throw new Error('OpenPencil store not initialized')+ return [...store.state.selectedIds].map((id) => store.graph.getNode(id)?.exportSettings ?? [])+ })+}++test('new selection starts with empty export settings', async () => {+ await createRectangles(1)++ await expect(exportItems()).toHaveCount(0)+ await expect(exportButton()).toHaveCount(0)+ await expect(page.getByTestId('export-preview-toggle')).toHaveCount(0)+ canvas.assertNoErrors()+})+test('add export row increases row count', async () => {const before = await exportItems().count()@@ -33,6 +85,7 @@ test('add export row increases row count', async () => {const after = await exportItems().count()expect(after).toBe(before + 1)+ await expect(exportButton()).toContainText('Export rect 1')canvas.assertNoErrors()})@@ -66,6 +119,15 @@ test('format selector changes to JPG', async () => {canvas.assertNoErrors()})+test('format selector does not offer FIG as an export format', async () => {+ const formatTrigger = exportItems().first().getByTestId('app-select-trigger').last()+ await formatTrigger.click()++ await expect(page.locator('[role="option"]').filter({ hasText: '.fig' })).toHaveCount(0)+ await page.locator('[role="option"]').filter({ hasText: 'JPG' }).click()+ canvas.assertNoErrors()+})+test('SVG format hides scale selector', async () => {const formatTrigger = exportItems().first().getByTestId('app-select-trigger').last()await formatTrigger.click()@@ -78,6 +140,81 @@ test('SVG format hides scale selector', async () => {canvas.assertNoErrors()})+test('format selector works with multiple export rows', async () => {+ await createRectangles(1, [+ [+ { scale: 1, format: 'png' },+ { scale: 1, format: 'svg' }+ ]+ ])++ const firstRowFormat = exportItems().nth(0).getByTestId('app-select-trigger').last()+ await firstRowFormat.click()+ await page.locator('[role="option"]').filter({ hasText: 'JPG' }).click()+ await canvas.waitForRender()++ const secondRowFormat = exportItems().nth(1).getByTestId('app-select-trigger').last()+ await secondRowFormat.click()+ await page.locator('[role="option"]').filter({ hasText: 'PDF' }).click()+ await canvas.waitForRender()++ expect(await selectedExportSettings()).toEqual([+ [+ { scale: 1, format: 'jpg' },+ { scale: 1, format: 'pdf' }+ ]+ ])+ canvas.assertNoErrors()+})++// The app prefers the File System Access save dialog when available, which never+// resolves in a headless browser. Unset it so the export falls back to the+// anchor-download path, which Playwright can capture as a `download` event.+async function forceBlobDownload() {+ await page.evaluate(() => {+ window.showSaveFilePicker = undefined+ })+}++// `createRectangles` makes fill-less rectangles, which have no visual bounds and+// export to nothing. Use createShape so the rectangle has a real fill and is+// actually exportable, then attach the export settings under test.+async function createExportableRect(settings: { scale: number; format: string }[]) {+ await page.evaluate((nodeSettings) => {+ const store = window.openPencil?.getStore?.()+ if (!store) throw new Error('OpenPencil store not initialized')+ for (const node of store.graph.getChildren(store.state.currentPageId)) {+ store.graph.deleteNode(node.id)+ }+ const id = store.createShape('RECTANGLE', 100, 100, 100, 100)+ store.graph.updateNode(id, { name: 'Export rect 1', exportSettings: nodeSettings })+ store.select([id])+ store.requestRender()+ }, settings)+ await canvas.waitForRender()+}++test('multiple export formats download as a single zip', async () => {+ await createExportableRect([+ { scale: 1, format: 'png' },+ { scale: 1, format: 'svg' }+ ])+ await forceBlobDownload()++ const [download] = await Promise.all([page.waitForEvent('download'), exportButton().click()])+ expect(download.suggestedFilename()).toBe('Export rect 1.zip')+ canvas.assertNoErrors()+})++test('a single export format downloads the file directly', async () => {+ await createExportableRect([{ scale: 1, format: 'png' }])+ await forceBlobDownload()++ const [download] = await Promise.all([page.waitForEvent('download'), exportButton().click()])+ expect(download.suggestedFilename()).toBe('Export rect [email protected]')+ canvas.assertNoErrors()+})+test('preview toggle shows image with blob src', async () => {const formatTrigger = exportItems().first().getByTestId('app-select-trigger').last()await formatTrigger.click()@@ -93,3 +230,51 @@ test('preview toggle shows image with blob src', async () => {expect(src).toMatch(/^blob:/)canvas.assertNoErrors()})++test('multi-select add and edit applies to all selected layers', async () => {+ await createRectangles(2)++ await page.getByTestId('export-section-add').click()+ await canvas.waitForRender()++ await expect(exportButton()).toContainText('Export 2 layers')+ expect(await selectedExportSettings()).toEqual([+ [{ scale: 1, format: 'png' }],+ [{ scale: 1, format: 'png' }]+ ])++ const scaleInput = exportItems().first().getByTestId('export-scale-input')+ await scaleInput.fill('2.5x')+ await scaleInput.press('Enter')+ await canvas.waitForRender()++ expect(await selectedExportSettings()).toEqual([+ [{ scale: 2.5, format: 'png' }],+ [{ scale: 2.5, format: 'png' }]+ ])+ canvas.assertNoErrors()+})++test('mixed export settings are indicated', async () => {+ await createRectangles(2, [[{ scale: 1, format: 'png' }], [{ scale: 2, format: 'jpg' }]])++ await expect(page.getByTestId('export-section')).toContainText('Mixed')+ canvas.assertNoErrors()+})++test('undo reverts export setting edits', async () => {+ await createRectangles(2)++ await page.getByTestId('export-section-add').click()+ await canvas.waitForRender()+ expect(await selectedExportSettings()).toEqual([+ [{ scale: 1, format: 'png' }],+ [{ scale: 1, format: 'png' }]+ ])++ await canvas.undo()++ expect(await selectedExportSettings()).toEqual([[], []])+ await expect(exportItems()).toHaveCount(0)+ canvas.assertNoErrors()+})diff --git a/tests/engine/io/fig/roundtrip/export-settings.test.ts b/tests/engine/io/fig/roundtrip/export-settings.test.tsnew file mode 100644index 000000000..0abfb0597--- /dev/null+++ b/tests/engine/io/fig/roundtrip/export-settings.test.ts@@ -0,0 +1,153 @@+import { beforeAll, describe, expect, test } from 'bun:test'++import {+ exportFigFile,+ importNodeChanges,+ initCodec,+ parseFigFile,+ SceneGraph,+ type NodeChange+} from '@open-pencil/core'+import { parseFigBuffer } from '@open-pencil/core/kiwi/fig/parse/core'+import { MAX_EXPORT_SCALE } from '@open-pencil/core/scene-graph'++function decodeExport(bytes: Uint8Array) {+ return parseFigBuffer(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength))+}++function doc(): NodeChange {+ return {+ guid: { sessionID: 0, localID: 0 },+ type: 'DOCUMENT',+ name: 'Document',+ visible: true,+ opacity: 1,+ phase: 'CREATED',+ transform: { m00: 1, m01: 0, m02: 0, m10: 0, m11: 1, m12: 0 }+ } as NodeChange+}++function canvas(): NodeChange {+ return {+ guid: { sessionID: 0, localID: 1 },+ parentIndex: { guid: { sessionID: 0, localID: 0 }, position: '!' },+ type: 'CANVAS',+ name: 'Page 1',+ visible: true,+ opacity: 1,+ phase: 'CREATED',+ transform: { m00: 1, m01: 0, m02: 0, m10: 0, m11: 1, m12: 0 }+ } as NodeChange+}++function frame(overrides: Partial<NodeChange> = {}): NodeChange {+ return {+ guid: { sessionID: 1, localID: 10 },+ parentIndex: { guid: { sessionID: 0, localID: 1 }, position: '"' },+ type: 'FRAME',+ name: 'Export settings frame',+ visible: true,+ opacity: 1,+ phase: 'CREATED',+ size: { x: 100, y: 100 },+ transform: { m00: 1, m01: 0, m02: 0, m10: 0, m11: 1, m12: 0 },+ ...overrides+ } as NodeChange+}++describe('fig roundtrip export settings', () => {+ beforeAll(async () => {+ await initCodec()+ })++ test('persists per-node export settings losslessly through plugin data', async () => {+ const graph = new SceneGraph()+ const page = graph.getPages()[0]+ const rect = graph.createNode('RECTANGLE', page.id, {+ name: 'Exportable rect',+ exportSettings: [+ { scale: 2, format: 'png' },+ { scale: 3, format: 'webp' }+ ]+ })++ const reimported = await parseFigFile((await exportFigFile(graph)).buffer as ArrayBuffer)+ const reimportedRect = [...reimported.getAllNodes()].find((node) => node.name === rect.name)++ expect(reimportedRect?.exportSettings).toEqual(rect.exportSettings)+ })++ test('maps native Figma PNG content-scale settings when plugin data is absent', () => {+ const graph = importNodeChanges([+ doc(),+ canvas(),+ frame({+ exportSettings: [+ {+ imageType: 'PNG',+ constraint: { type: 'CONTENT_SCALE', value: 2 }+ },+ {+ imageType: 'GIF',+ constraint: { type: 'CONTENT_SCALE', value: 4 }+ }+ ]+ })+ ])+ const importedFrame = [...graph.getAllNodes()].find(+ (node) => node.name === 'Export settings frame'+ )++ expect(importedFrame?.exportSettings).toEqual([{ scale: 2, format: 'png' }])+ })++ test('does not serialize export settings plugin data for a default node', async () => {+ const graph = new SceneGraph()+ const page = graph.getPages()[0]+ const rect = graph.createNode('RECTANGLE', page.id, { name: 'Default export settings rect' })++ const decoded = decodeExport(await exportFigFile(graph))+ const exportedRect = decoded.nodeChanges.find((nodeChange) => nodeChange.name === rect.name)++ expect(+ exportedRect?.pluginData?.some(+ (entry) => entry.pluginID === 'open-pencil' && entry.key === 'exportSettings'+ ) ?? false+ ).toBe(false)+ })++ test('does not resurrect native export settings after the user clears all rows', async () => {+ // Imported node carries NATIVE export settings (no plugin override).+ const graph = importNodeChanges([+ doc(),+ canvas(),+ frame({+ exportSettings: [{ imageType: 'PNG', constraint: { type: 'CONTENT_SCALE', value: 2 } }]+ })+ ])+ const node = [...graph.getAllNodes()].find((n) => n.name === 'Export settings frame')+ if (!node) throw new Error('imported frame not found')+ expect(node.exportSettings).toEqual([{ scale: 2, format: 'png' }])++ // User removes every export row; the raw native settings must be dropped so they+ // don't come back via the import fallback on reopen.+ graph.updateNode(node.id, { exportSettings: [] })+ expect(node.source.fig.rawNodeFields?.exportSettings).toBeUndefined()++ const reimported = await parseFigFile((await exportFigFile(graph)).buffer as ArrayBuffer)+ const reNode = [...reimported.getAllNodes()].find((n) => n.name === 'Export settings frame')+ expect(reNode?.exportSettings).toEqual([])+ })++ test('clamps an out-of-range native export scale at the import boundary', () => {+ const graph = importNodeChanges([+ doc(),+ canvas(),+ frame({+ exportSettings: [{ imageType: 'PNG', constraint: { type: 'CONTENT_SCALE', value: 999999 } }]+ })+ ])+ const node = [...graph.getAllNodes()].find((n) => n.name === 'Export settings frame')+ expect(node?.exportSettings).toEqual([{ scale: MAX_EXPORT_SCALE, format: 'png' }])+ })+})