M4.44: PDF presets: built-ins in code, saved presets, Edit > PDF Presets

Built-in presets are generated in code (VectorCraft Default, High
Quality Print, Press Quality, Smallest File Size and PDF/X-1a, X-3,
X-4, the latter listed as not supported yet) and read-only. Saved
presets live with the preferences (Prefs.pdf_presets) and work as
`preset` wherever PDF options are taken: document.exportPdf,
pdfSettings, export/serialize as PDF and .ai saves.

pdf.preset.list / save / delete / export / import manage them
(.vcpdfpresets files; opening one imports it). The Save PDF dialog's
Save Preset… saves its settings under a name; Edit > PDF Presets…
(ui.pdfPresetsDialog) lists the presets with each one's description and
differences from the default, with New…, Edit… (the Save PDF dialog as
a preset editor, ui.pdfPresetDialog), Delete, Import… and Export….
document.pdfSettings now lists what differs from the chosen preset.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

crates/engine/src/cmd/fileio/mod.rs

@@ -306,12 +306,13 @@ fn format_filters() -> impl Iterator<Item = (&'static str, &'static [&'static st
 }
 
 /// Open-dialog filters: "All readable files" first, then one per readable format, then swatch
-/// libraries (which open in the library panel) and flattener presets (imported).
+/// libraries (which open in the library panel), flattener presets and PDF presets (imported).
 pub fn open_filters() -> impl Iterator<Item = (&'static str, &'static [&'static str])> {
     std::iter::once(("All readable files", OPEN_EXTS))
         .chain(format_filters())
         .chain(std::iter::once(("Swatch libraries", super::swatchlib::LIBRARY_EXTS)))
         .chain(std::iter::once(("Flattener presets", super::flatten::PRESET_EXTS)))
+        .chain(std::iter::once(("PDF presets", super::pdfcmds::PRESET_EXTS)))
 }
 
 /// File → Place dialog filters: "All placeable files", then one per readable format, then text.

crates/engine/src/cmd/fileio/pdf.rs

@@ -24,7 +24,12 @@ pub(super) const OPTIONS: &[FormatOption] = &[
     super::ARTBOARDS,
     super::RANGE,
     super::USE_ARTBOARDS,
-    FormatOption { name: "preset", ty: "string", default: "\"VectorCraft Default\"", description: "the PDF preset the other options apply over" },
+    FormatOption {
+        name: "preset",
+        ty: "string",
+        default: "\"VectorCraft Default\"",
+        description: "the PDF preset the other options apply over (built-in or saved: pdf.preset.list)",
+    },
     FormatOption { name: "standard", ty: "string", default: "\"none\"", description: "none | pdfA2b (PDF/X is not supported yet)" },
     FormatOption { name: "compatibility", ty: "string", default: "\"1.7\"", description: "PDF version: 1.4 | 1.5 | 1.6 | 1.7 | 2.0" },
     FormatOption {
@@ -48,7 +53,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Export PDF",
             [],
             None,
-            "{path?, preset?: \"VectorCraft Default\", artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), standard?: none|pdfA2b|pdfX1a|pdfX3|pdfX4, compatibility?: 1.4|1.5|1.6|1.7 (default)|2.0, preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, PDF/A refuses it), thumbnails?, fastWebView?, viewAfterSaving? (the app opens the written file), createLayers?, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength}, compressText?: true}, marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6}, bleed?: {useDocument, top, bottom, left, right} (pt), output?: {conversion: none|destination|preserveNumbers, destination, profiles: none|all|destination|taggedSource, outputIntent, outputCondition, outputConditionId, registry, trapped}, advanced?: {fontSubsetPercent: 100, outlineText: true, overprint: preserve|discard}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; PDF/X, passwords and PDF/A-2b at 2.0 are refused. document.export {format: pdf} takes the same options",
+            "{path?, preset?: \"VectorCraft Default\" (built-in or saved: pdf.preset.list), artboard? | artboards?: [i…] | range?: \"1-3, 5\" (1-based; default all, one page each), standard?: none|pdfA2b|pdfX1a|pdfX3|pdfX4, compatibility?: 1.4|1.5|1.6|1.7 (default)|2.0, preserveEditing? (on in VectorCraft Default: the native document as an embedded file, which document.open restores; choosing a standard turns it off, PDF/A refuses it), thumbnails?, fastWebView?, viewAfterSaving? (the app opens the written file), createLayers?, compression?: {color?, gray?: {downsample: none|average|subsample|bicubic, ppi: 300, abovePpi: 450, compression: none|zip|jpeg|jpeg2000|auto, quality: minimum|low|medium|high|maximum}, mono?: {downsample, ppi: 1200, abovePpi: 1800, compression: none|ccittG3|ccittG4|zip|runLength}, compressText?: true}, marks?: {trim, registration, colorBars, pageInfo, kind: roman|japanese, weight: 0.25, offset: 6}, bleed?: {useDocument, top, bottom, left, right} (pt), output?: {conversion: none|destination|preserveNumbers, destination, profiles: none|all|destination|taggedSource, outputIntent, outputCondition, outputConditionId, registry, trapped}, advanced?: {fontSubsetPercent: 100, outlineText: true, overprint: preserve|discard}, security?: {openPassword, permissionsPassword, printing: none|low|high, changes: none|pages|forms|comments|any, copy, screenReader, plaintextMetadata}} → {path, bytes, warnings}; no path → {dataBase64, bytes, warnings}. The options apply over the preset (null keeps its value); options accepted but not applied yet come back as warnings; PDF/X, passwords and PDF/A-2b at 2.0 are refused. document.export {format: pdf} takes the same options",
             has_doc,
             export_pdf
         ),
@@ -57,7 +62,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "PDF Settings",
             [],
             None,
-            "{preset?, includeDocument?: false, …document.exportPdf options} → {settings (the preset with the options applied), presets: [name…], changed: [{option: \"compression.compressText\", value}] (what differs from the defaults), warnings}; includeDocument also exports the active document in memory and adds its warnings (pattern strokes, effects left out…)",
+            "{preset?, includeDocument?: false, …document.exportPdf options} → {settings (the preset with the options applied), presets: [name…], changed: [{option: \"compression.compressText\", value}] (what differs from the preset), warnings}; includeDocument also exports the active document in memory and adds its warnings (pattern strokes, effects left out…)",
             always,
             pdf_settings
         ),
@@ -66,7 +71,12 @@ pub fn specs() -> Vec<CommandSpec> {
 
 /// Every preset name: the built-in ones, then the saved ones ([`crate::Prefs::pdf_presets`]).
 pub fn presets(s: &Session) -> Vec<String> {
-    vectorcraft_pdf::builtin_presets().into_iter().map(|p| p.name).chain(s.prefs.pdf_presets.iter().map(|p| p.name.clone())).collect()
+    names(&s.prefs.pdf_presets)
+}
+
+/// The built-in preset names, then those of `saved`.
+fn names(saved: &[PdfPreset]) -> Vec<String> {
+    vectorcraft_pdf::builtin_presets().into_iter().map(|p| p.name).chain(saved.iter().map(|p| p.name.clone())).collect()
 }
 
 /// The preset `name` names: a built-in one (any case; `default` is the app default) or one of
@@ -76,10 +86,9 @@ pub fn find_preset(name: &str, saved: &[PdfPreset]) -> Option<PdfPreset> {
 }
 
 fn preset(cmd: &str, name: &str, saved: &[PdfPreset]) -> Result<PdfSettings> {
-    find_preset(name, saved).map(|p| p.settings).ok_or_else(|| {
-        let names: Vec<String> = vectorcraft_pdf::builtin_presets().into_iter().map(|p| p.name).chain(saved.iter().map(|p| p.name.clone())).collect();
-        bad(cmd, format!("unknown PDF preset `{name}` (presets: {})", names.join(", ")))
-    })
+    find_preset(name, saved)
+        .map(|p| p.settings)
+        .ok_or_else(|| bad(cmd, format!("unknown PDF preset `{name}` (presets: {})", names(saved).join(", "))))
 }
 
 /// The settings of the preset `p` names (default: [`DEFAULT_PRESET`]), before `p`'s options.

crates/engine/src/cmd/fileio/tests.rs

@@ -146,7 +146,7 @@ fn open_exts_cover_every_readable_format() {
     }
     let filters: Vec<_> = open_filters().collect();
     assert_eq!(filters[0], ("All readable files", OPEN_EXTS));
-    assert_eq!(filters.len(), 3 + FORMATS.iter().filter(|f| f.read).count(), "and swatch libraries and flattener presets");
+    assert_eq!(filters.len(), 4 + FORMATS.iter().filter(|f| f.read).count(), "and swatch libraries, flattener presets and PDF presets");
 }
 
 #[test]

crates/engine/src/cmd/mod.rs

@@ -40,6 +40,7 @@ mod panelcmds;
 mod path;
 mod pathops;
 mod patterncmds;
+pub mod pdfcmds;
 mod place;
 pub mod prefscmds;
 pub mod rasterfx;
@@ -220,6 +221,7 @@ pub fn command_specs() -> &'static [CommandSpec] {
         v.extend(newdoc::specs());
         v.extend(place::specs());
         v.extend(links::specs());
+        v.extend(pdfcmds::specs());
         v
     })
 }

crates/engine/src/cmd/pdfcmds.rs

@@ -0,0 +1,210 @@
+//! Edit → PDF Presets: `pdf.preset.list`, `save`, `delete`, `export` and `import`. The built-in
+//! presets are generated in code ([`vectorcraft_pdf::builtin_presets`]) and read-only; the user's
+//! live in [`crate::Prefs::pdf_presets`]. Any of their names works as `preset` wherever PDF
+//! options are taken (`document.exportPdf`, `document.export`, a `.ai` save…).
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use vectorcraft_pdf::{PdfPreset, builtin_preset, builtin_presets};
+
+use super::fileio::pdf::{find_preset, resolve};
+use super::*;
+
+/// The `format` of a PDF presets file, also its extension.
+pub const PRESET_FORMAT: &str = "vcpdfpresets";
+
+/// The extensions of PDF presets files (opening one imports it).
+pub const PRESET_EXTS: &[&str] = &[PRESET_FORMAT];
+
+/// What `pdf.preset.export` writes and `pdf.preset.import` reads.
+#[derive(Serialize, Deserialize)]
+struct PresetFile {
+    format: String,
+    #[serde(default)]
+    presets: Vec<PdfPreset>,
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        cmd!(
+            query "pdf.preset.list",
+            "PDF Presets",
+            [],
+            None,
+            "{} → {presets: [{name, builtIn, supported (the writer produces its standard), description, settings (as document.pdfSettings)}]} the built-in presets (VectorCraft Default first), then the saved ones; any of these names works as `preset` wherever PDF options are taken",
+            always,
+            list
+        ),
+        cmd!(
+            query "pdf.preset.save",
+            "Save PDF Preset",
+            [],
+            None,
+            "{name?: (default: a new \"PDF Preset N\"), newName?: rename it, description?, preset?: the preset to start from (default: the saved preset `name`, else VectorCraft Default), …document.exportPdf options} create or change a saved preset (built-in presets are read-only; passwords are never stored) → {name, created, settings}",
+            always,
+            save
+        ),
+        cmd!(query "pdf.preset.delete", "Delete PDF Preset", [], None, "{name} delete a saved preset (built-in ones stay) → {deleted: name}", always, delete),
+        cmd!(
+            query "pdf.preset.export",
+            "Export PDF Presets",
+            [],
+            None,
+            "{names?: [preset names, built-in ones too] (default: every saved preset), path?} write the presets as a .vcpdfpresets file (JSON) → {path, count}; without path → {data: the file's text, count}",
+            always,
+            export
+        ),
+        cmd!(
+            query "pdf.preset.import",
+            "Import PDF Presets",
+            [],
+            None,
+            "{path? | data?: file text | dataBase64?, replace?: false (replace saved presets of the same names; else imported ones whose name is taken get a number)} add the presets of a .vcpdfpresets file (as pdf.preset.export writes) to the saved ones → {imported: [names]}",
+            always,
+            import
+        ),
+    ]
+}
+
+impl Session {
+    /// Every PDF preset: the built-in ones, then the saved ones.
+    pub fn pdf_presets(&self) -> Vec<PdfPreset> {
+        let mut v = builtin_presets();
+        v.extend(self.prefs.pdf_presets.iter().cloned());
+        v
+    }
+
+    /// The first free "PDF Preset N": the name a new preset gets.
+    pub fn new_pdf_preset_name(&self) -> String {
+        (1..).map(|i| format!("PDF Preset {i}")).find(|n| !self.pdf_preset_taken(n, None)).unwrap_or_default()
+    }
+
+    /// The index of the saved PDF preset `name` (any case).
+    fn pdf_saved_index(&self, name: &str) -> Option<usize> {
+        self.prefs.pdf_presets.iter().position(|q| q.name.eq_ignore_ascii_case(name.trim()))
+    }
+
+    /// Whether `name` is taken by a built-in PDF preset or a saved one other than the one at
+    /// `except`.
+    fn pdf_preset_taken(&self, name: &str, except: Option<usize>) -> bool {
+        builtin_preset(name).is_some() || self.pdf_saved_index(name).is_some_and(|i| Some(i) != except)
+    }
+}
+
+fn row(p: PdfPreset, built_in: bool) -> Value {
+    json!({ "name": p.name, "builtIn": built_in, "supported": p.settings.check().is_ok(), "description": p.description, "settings": p.settings })
+}
+
+fn list(s: &mut Session, _: &Value) -> Result<Value> {
+    let rows = builtin_presets().into_iter().map(|p| row(p, true)).chain(s.prefs.pdf_presets.iter().cloned().map(|p| row(p, false)));
+    Ok(json!({ "presets": rows.collect::<Vec<_>>() }))
+}
+
+fn save(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "pdf.preset.save";
+    let name = match str_param(p, "name").map(str::trim) {
+        Some("") => return Err(bad(C, "`name` is empty")),
+        Some(n) => n.to_string(),
+        None => s.new_pdf_preset_name(),
+    };
+    if builtin_preset(&name).is_some() {
+        return Err(bad(C, format!("`{name}` is a built-in preset and is read-only: save it under another name")));
+    }
+    let at = s.pdf_saved_index(&name);
+    let saved = at.and_then(|i| s.prefs.pdf_presets.get(i)).cloned();
+    // A saved preset changes from its own settings unless `preset` says where to start.
+    let mut q = if p.is_object() { p.clone() } else { json!({}) };
+    if let (Some(old), None) = (&saved, str_param(p, "preset")) {
+        q["preset"] = json!(old.name);
+    }
+    let mut settings = resolve(C, &q, &s.prefs.pdf_presets)?;
+    settings.clear_passwords();
+    let name = match str_param(p, "newName").map(str::trim) {
+        Some("") => return Err(bad(C, "`newName` is empty")),
+        Some(n) if s.pdf_preset_taken(n, at) => return Err(bad(C, format!("a preset named `{n}` exists"))),
+        Some(n) => n.to_string(),
+        None => saved.as_ref().map_or(name, |old| old.name.clone()),
+    };
+    let description = str_param(p, "description").map(str::to_string).or_else(|| saved.map(|old| old.description)).unwrap_or_default();
+    let preset = PdfPreset { name: name.clone(), description, settings: settings.clone() };
+    match at.and_then(|i| s.prefs.pdf_presets.get_mut(i)) {
+        Some(slot) => *slot = preset,
+        None => s.prefs.pdf_presets.push(preset),
+    }
+    Ok(json!({ "name": name, "created": at.is_none(), "settings": settings }))
+}
+
+fn delete(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "pdf.preset.delete";
+    let name = str_param(p, "name").ok_or_else(|| bad(C, "missing `name`"))?;
+    if builtin_preset(name).is_some() {
+        return Err(bad(C, format!("`{name}` is a built-in preset and stays")));
+    }
+    let i = s.pdf_saved_index(name).ok_or_else(|| bad(C, format!("no saved PDF preset named `{name}`")))?;
+    Ok(json!({ "deleted": s.prefs.pdf_presets.remove(i).name }))
+}
+
+fn export(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "pdf.preset.export";
+    let presets = match p.get("names").and_then(Value::as_array) {
+        Some(names) => {
+            let find = |n: &Value| {
+                let n = n.as_str().unwrap_or_default();
+                find_preset(n, &s.prefs.pdf_presets).ok_or_else(|| bad(C, format!("no PDF preset named `{n}`")))
+            };
+            names.iter().map(find).collect::<Result<Vec<_>>>()?
+        }
+        None => s.prefs.pdf_presets.clone(),
+    };
+    if presets.is_empty() {
+        return Err(bad(C, "no saved presets to export (name built-in ones in `names`)"));
+    }
+    let count = presets.len();
+    let text = serde_json::to_string_pretty(&PresetFile { format: PRESET_FORMAT.into(), presets }).map_err(|e| bad(C, e.to_string()))?;
+    match str_param(p, "path") {
+        Some(path) => {
+            super::fileio::write_file(path, text.as_bytes())?;
+            Ok(json!({"path": path, "count": count}))
+        }
+        None => Ok(json!({"data": text, "count": count})),
+    }
+}
+
+fn import(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "pdf.preset.import";
+    let bytes = match (str_param(p, "path"), str_param(p, "data"), str_param(p, "dataBase64")) {
+        (Some(path), ..) => super::fileio::read_file(path)?,
+        (None, Some(text), _) => text.as_bytes().to_vec(),
+        (None, None, Some(b64)) => vectorcraft_format::base64_decode(b64).ok_or_else(|| bad(C, "bad dataBase64"))?,
+        _ => return Err(bad(C, "give `path`, `data` or `dataBase64`")),
+    };
+    let file: PresetFile = serde_json::from_slice(&bytes).map_err(|e| bad(C, format!("not a PDF presets file: {e}")))?;
+    if file.format != PRESET_FORMAT {
+        return Err(bad(C, format!("not a PDF presets file (format `{}`)", file.format)));
+    }
+    // Values a hand-edited file may carry are refused as the export options refuse them.
+    for q in &file.presets {
+        q.settings.check_values().map_err(|e| bad(C, format!("`{}`: {e}", q.name)))?;
+    }
+    let replace = bool_or(p, "replace", false);
+    let mut imported = vec![];
+    for mut preset in file.presets {
+        preset.settings.clear_passwords();
+        let base = Some(preset.name.trim()).filter(|n| !n.is_empty()).unwrap_or("PDF Preset").to_string();
+        match s.pdf_saved_index(&base).filter(|_| replace) {
+            Some(i) => {
+                if let Some(slot) = s.prefs.pdf_presets.get_mut(i) {
+                    preset.name = slot.name.clone();
+                    imported.push(preset.name.clone());
+                    *slot = preset;
+                }
+            }
+            None => {
+                preset.name = unique_name(&base, |n| s.pdf_preset_taken(n, None));
+                imported.push(preset.name.clone());
+                s.prefs.pdf_presets.push(preset);
+            }
+        }
+    }
+    Ok(json!({ "imported": imported }))
+}