Skip to content

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.ts
index 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 = false
destroy(): void {
diff --git a/packages/core/src/io/formats/raster/render.ts b/packages/core/src/io/formats/raster/render.ts
index 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.ts
index 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, setVariableColorResolver
export { 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.ts
index 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 = pluginData
if (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.ts
index 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.ts
new file mode 100644
index 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.ts
index 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.ts
index 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.ts
index 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 = null
if (changeKeys.some((key) => RAW_TRANSFORM_KEYS.has(key))) node.source.fig.rawTransform = null
if (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.ts
index 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: string
command: 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 | Uint8Array
type 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.vue
index 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.vue
new file mode 100644
index 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.vue
index 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 = true
try {
- 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>
<div
v-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
+ <ExportScaleInput
v-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.ts
index 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.ts
new file mode 100644
index 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' }])
+ })
+})