Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Format registry: one table of formats, extensions and options (#5215) (#5217)

William Dunn17f0d6bc68b9
diff --git a/apps/solidcraft-web/src/files.rs b/apps/solidcraft-web/src/files.rs
index 4c31697731..4bedaed404 100644
--- a/apps/solidcraft-web/src/files.rs
+++ b/apps/solidcraft-web/src/files.rs
@@ -499,7 +499,9 @@ fn input_picker(files: &Rc<Files>, intent: Intent) {
let Some(doc) = web_sys::window().and_then(|w| w.document()) else { return };
let Ok(input) = doc.create_element("input").map(|e| e.unchecked_into::<web_sys::HtmlInputElement>()) else { return };
input.set_type("file");
- input.set_accept(".solidcraft,.solvecraft,.json,.step,.stp,.3mf,.stl,.obj,.glb,.gltf");
+ // Everything the browser build imports, from the format registry (no cadmpeg formats here).
+ let accept = solidcraft_engine::io::formats::open_extensions(false).iter().map(|e| format!(".{e}")).collect::<Vec<_>>().join(",");
+ input.set_accept(&accept);
// Attached (hidden) while it is open: some browsers ignore a click on a detached input.
let _ = input.set_attribute("style", "display:none");
if let Some(body) = doc.body() {
diff --git a/apps/solidcraft/src/main.rs b/apps/solidcraft/src/main.rs
index 1eec426ed7..72ab4d6f95 100644
--- a/apps/solidcraft/src/main.rs
+++ b/apps/solidcraft/src/main.rs
@@ -197,6 +197,24 @@ impl App {
}
}
+/// Linux file dialogs match patterns by case, so each extension goes in as lower and upper
+/// case, plus FreeCAD's own mixed casing.
+fn case_variants(exts: &[&str]) -> Vec<String> {
+ let mut all: Vec<String> = Vec::new();
+ for e in exts {
+ let mut forms = vec![e.to_ascii_lowercase(), e.to_ascii_uppercase()];
+ if e.eq_ignore_ascii_case("fcstd") {
+ forms.push("FCStd".into());
+ }
+ for v in forms {
+ if !all.contains(&v) {
+ all.push(v);
+ }
+ }
+ }
+ all
+}
+
fn services(cc: &eframe::CreationContext<'_>) -> Services {
let parent = rfd::AsyncFileDialog::new().set_parent(cc);
let open_parent = parent.clone();
@@ -208,48 +226,14 @@ fn services(cc: &eframe::CreationContext<'_>) -> Services {
let mut dialog = open_parent.clone();
if !first.is_empty() {
let label = first.iter().map(|e| e.to_uppercase()).collect::<Vec<_>>().join(", ");
- let both: Vec<String> = first.iter().flat_map(|e| [e.to_lowercase(), e.to_uppercase()]).collect();
- dialog = dialog.add_filter(label, &both);
+ dialog = dialog.add_filter(label, &case_variants(first));
+ }
+ // The groups come from the format registry, so a new format joins this dialog by itself.
+ dialog = dialog.add_filter("Designs, CAD files and meshes", &case_variants(&io::formats::open_extensions(true)));
+ for (label, exts) in io::formats::import_filters(true) {
+ dialog = dialog.add_filter(label, &case_variants(&exts));
}
- let future = dialog
- .add_filter(
- "Designs, CAD files and meshes",
- &[
- io::DESIGN_EXT,
- io::LEGACY_DESIGN_EXT,
- "json",
- "step",
- "stp",
- "STEP",
- "STP",
- "igs",
- "iges",
- "IGS",
- "IGES",
- "FCStd",
- "fcstd",
- "3dm",
- "3DM",
- "3mf",
- "3MF",
- "stl",
- "STL",
- "obj",
- "OBJ",
- "glb",
- "GLB",
- "gltf",
- "GLTF",
- ],
- )
- .add_filter("SolidCraft design (container or JSON)", &[io::DESIGN_EXT, io::LEGACY_DESIGN_EXT, "json"])
- .add_filter("STEP", &["step", "stp", "STEP", "STP"])
- .add_filter("IGES", &["igs", "iges", "IGS", "IGES"])
- .add_filter("FreeCAD and Rhino", &["FCStd", "fcstd", "3dm", "3DM"])
- .add_filter("Mesh (3MF, STL, OBJ, glTF)", &["3mf", "3MF", "stl", "STL", "obj", "OBJ", "glb", "GLB", "gltf", "GLTF"])
- .add_filter("Sketch drawings (DXF, SVG)", &["dxf", "DXF", "svg", "SVG"])
- .add_filter("All files", &["*"])
- .pick_file();
+ let future = dialog.add_filter("All files", &["*"]).pick_file();
Box::pin(async move { future.await.map(|p| p.path().to_string_lossy().into_owned()) })
})),
// One kind of file (the agent chat's attachments): only the types it names, as given and in
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index 22458ddb06..d306870dce 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -1095,4 +1095,33 @@ mod tests {
assert!(stopped.world_state().bodies.is_empty());
std::fs::remove_dir_all(dir).unwrap();
}
+
+ /// Every option the format registry offers is a parameter its owning command documents,
+ /// so the registry and the commands can't drift apart.
+ #[test]
+ fn registry_options_name_documented_command_parameters() {
+ use solidcraft_io::formats;
+ let params_of = |id: &str| crate::find_command(id).map(|c| c.params).unwrap_or_else(|| panic!("registry names unknown command {id}"));
+ for f in formats::FORMATS {
+ if let Some(import) = &f.import {
+ for o in import.options {
+ for id in ["doc.open", if import.target == formats::ImportTarget::Mesh { "file.insert_mesh" } else { "file.insert_step" }] {
+ assert!(params_of(id).contains(o.param), "{}: `{}` is not a documented parameter of {id}", f.id, o.param);
+ }
+ }
+ }
+ if let Some(export) = &f.export {
+ let params = params_of(export.command);
+ if let Some(format) = export.format {
+ assert!(params.contains(format), "{}: `{format}` is not a documented format of {}", f.id, export.command);
+ }
+ for o in export.options {
+ assert!(params.contains(o.param), "{}: `{}` is not a documented parameter of {}", f.id, o.param, export.command);
+ }
+ }
+ }
+ for o in formats::DESIGN_SAVE_OPTIONS {
+ assert!(params_of("file.save_as").contains(o.param), "`{}` is not a documented parameter of file.save_as", o.param);
+ }
+ }
}
diff --git a/crates/io/src/formats.rs b/crates/io/src/formats.rs
new file mode 100644
index 0000000000..114daccec2
--- /dev/null
+++ b/crates/io/src/formats.rs
@@ -0,0 +1,476 @@
+//! The format registry: one table describing every file format SolidCraft reads or writes,
+//! with the options each one takes. The UI's pickers and panels, the hosts' file-dialog
+//! filters and the web `accept` list all derive from this table, so a new format (or a new
+//! option) is added in one place. The writers and readers themselves stay where they are
+//! ([`crate::Format`] and the `read_*`/`write_*` functions); a row here only *describes* a
+//! format and names the engine command and parameters that drive it.
+
+/// Which side of the save/export line a format sits on. Design serializations hold the whole
+/// document and reopen losslessly (Save / Save As); artifacts are derived output (Export) or
+/// foreign input (Import).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Role {
+ Design,
+ Artifact,
+}
+
+/// What an imported file becomes.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ImportTarget {
+ /// A design file: opens as a tab, or joins a design as a linked component
+ /// (`component.insert_design`).
+ Design,
+ /// B-rep CAD read as an Import base feature (`doc.open` / `file.insert_step`).
+ Brep,
+ /// Mesh read as a MeshImport feature (`doc.open` / `file.insert_mesh`).
+ Mesh,
+ /// A 2D drawing read into the active sketch (`sketch.insert_dxf` / `sketch.insert_svg`).
+ Sketch,
+}
+
+/// What an export is of.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ExportScope {
+ /// Chosen bodies, or every body when none are chosen (the command's `bodies` parameter).
+ Bodies,
+ /// The whole design or assembly: no bodies parameter.
+ Design,
+ /// The current camera view: the command also needs a `camera`.
+ View,
+}
+
+/// How a format imports.
+pub struct ImportSpec {
+ pub target: ImportTarget,
+ /// Options offered at import time; each `param` is a parameter of `doc.open` and of the
+ /// matching `file.insert_*` command.
+ pub options: &'static [OptionSpec],
+ /// Read through cadmpeg, which is not built for wasm (see `crate::native_cad`).
+ pub native_only: bool,
+}
+
+/// How a format exports.
+pub struct ExportSpec {
+ /// The engine command that writes it.
+ pub command: &'static str,
+ /// The command's `format` value, when the path's extension alone doesn't name it.
+ pub format: Option<&'static str>,
+ /// Options offered at export time; each `param` is a parameter of `command`.
+ pub options: &'static [OptionSpec],
+ pub scope: ExportScope,
+ /// A lossless serialization of the whole document (reopens as the same design).
+ pub lossless: bool,
+}
+
+/// One option of a format, mapped onto one parameter of the owning command.
+pub struct OptionSpec {
+ /// The command parameter this option fills.
+ pub param: &'static str,
+ /// English label; the UI translates it at paint time.
+ pub label: &'static str,
+ pub kind: OptionKind,
+}
+
+/// What an option's value looks like. `Choice` values are sent as strings; the labels are
+/// English and translated by the UI.
+pub enum OptionKind {
+ Bool {
+ default: bool,
+ },
+ /// (value as the command takes it, English label).
+ Choice {
+ choices: &'static [(&'static str, &'static str)],
+ default: usize,
+ },
+ Text {
+ default: &'static str,
+ hint: &'static str,
+ },
+ Number {
+ default: f64,
+ min: f64,
+ max: f64,
+ unit: &'static str,
+ },
+}
+
+/// One file format: how it is named, matched and driven.
+pub struct FormatSpec {
+ /// Stable id of ours (the command's `format` value where one exists).
+ pub id: &'static str,
+ /// English label; the UI translates it at paint time.
+ pub label: &'static str,
+ /// Extensions, lower-case, preferred first. Matching is case-insensitive; hosts add the
+ /// case variants their file dialogs need.
+ pub extensions: &'static [&'static str],
+ pub role: Role,
+ pub import: Option<ImportSpec>,
+ pub export: Option<ExportSpec>,
+}
+
+/// Which way is up in a STEP, IGES, FreeCAD or Rhino file (see `doc.open`).
+const UP_Z: OptionSpec = OptionSpec {
+ param: "up",
+ label: "Up axis",
+ kind: OptionKind::Choice { choices: &[("z", "Keep the file's axes (Z up)"), ("y", "The file has Y up")], default: 0 },
+};
+
+/// glTF has Y up, so standing the import up is the default (see `file.insert_mesh`).
+const UP_Y: OptionSpec = OptionSpec {
+ param: "up",
+ label: "Up axis",
+ kind: OptionKind::Choice { choices: &[("y", "The file has Y up"), ("z", "Keep the file's axes (Z up)")], default: 0 },
+};
+
+/// What imported bodies are named after (see [`crate::StepNames`]).
+const STEP_NAMES: OptionSpec = OptionSpec {
+ param: "names",
+ label: "Body names",
+ kind: OptionKind::Choice {
+ choices: &[("solid", "The solid's own name"), ("product", "The part that holds it"), ("instance", "The assembly occurrence")],
+ default: 0,
+ },
+};
+
+const BREP_IMPORT: &[OptionSpec] = &[UP_Z, STEP_NAMES];
+
+/// Binary is the `stl` format value, ASCII is `stla` (see `file.export`).
+const STL_ENCODING: OptionSpec =
+ OptionSpec { param: "format", label: "Encoding", kind: OptionKind::Choice { choices: &[("stl", "Binary"), ("stla", "ASCII")], default: 0 } };
+
+const URDF_OPTIONS: &[OptionSpec] = &[
+ OptionSpec { param: "mesh_prefix", label: "Mesh file prefix", kind: OptionKind::Text { default: "", hint: "package://robot/meshes/" } },
+ OptionSpec { param: "effort", label: "Joint effort", kind: OptionKind::Number { default: 1000.0, min: 0.0, max: 1e9, unit: "" } },
+ OptionSpec { param: "velocity", label: "Joint velocity", kind: OptionKind::Number { default: 10.0, min: 0.0, max: 1e9, unit: "" } },
+];
+
+const VIEW_DXF_OPTIONS: &[OptionSpec] = &[
+ OptionSpec {
+ param: "hidden",
+ label: "Hidden edges",
+ kind: OptionKind::Choice { choices: &[("omit", "Omitted"), ("dashed", "Dashed")], default: 0 },
+ },
+ OptionSpec { param: "tolerance", label: "Tolerance", kind: OptionKind::Number { default: 0.01, min: 0.0001, max: 1.0, unit: "mm" } },
+];
+
+/// The options of `file.save` and `file.save_as` beyond the path (the design row itself; Save
+/// As offers these).
+pub static DESIGN_SAVE_OPTIONS: &[OptionSpec] = &[
+ OptionSpec {
+ param: "format",
+ label: "Format",
+ kind: OptionKind::Choice { choices: &[("container", "SolidCraft container"), ("json", "Plain JSON design")], default: 0 },
+ },
+ OptionSpec {
+ param: "compression",
+ label: "Compression",
+ kind: OptionKind::Choice { choices: &[("fast", "Fast"), ("compact", "Compact")], default: 0 },
+ },
+ OptionSpec { param: "cache", label: "Geometry cache", kind: OptionKind::Bool { default: true } },
+ OptionSpec { param: "preview", label: "Display preview", kind: OptionKind::Bool { default: false } },
+];
+
+/// Every format, designs first, then artifacts roughly as the Export list shows them. The
+/// first row matching an extension wins in [`for_path`], so the design row stays above the
+/// design-JSON row and the sketch DXF row above the view DXF row.
+pub static FORMATS: &[FormatSpec] = &[
+ FormatSpec {
+ id: "design",
+ label: "SolidCraft design",
+ extensions: &[crate::DESIGN_EXT, crate::LEGACY_DESIGN_EXT, "json"],
+ role: Role::Design,
+ import: Some(ImportSpec { target: ImportTarget::Design, options: &[], native_only: false }),
+ export: None,
+ },
+ FormatSpec {
+ id: "step",
+ label: "STEP",
+ extensions: &["step", "stp"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Brep, options: BREP_IMPORT, native_only: false }),
+ export: Some(ExportSpec { command: "file.export", format: None, options: &[], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "iges",
+ label: "IGES",
+ extensions: &["igs", "iges"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Brep, options: BREP_IMPORT, native_only: false }),
+ export: Some(ExportSpec { command: "file.export", format: None, options: &[], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "fcstd",
+ label: "FreeCAD",
+ extensions: &["fcstd"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Brep, options: BREP_IMPORT, native_only: true }),
+ export: None,
+ },
+ FormatSpec {
+ id: "3dm",
+ label: "Rhino",
+ extensions: &["3dm"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Brep, options: BREP_IMPORT, native_only: true }),
+ export: None,
+ },
+ FormatSpec {
+ id: "stl",
+ label: "STL",
+ extensions: &["stl"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Mesh, options: &[], native_only: false }),
+ export: Some(ExportSpec { command: "file.export", format: None, options: &[STL_ENCODING], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "3mf",
+ label: "3MF",
+ extensions: &["3mf"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Mesh, options: &[], native_only: false }),
+ export: Some(ExportSpec { command: "file.export", format: None, options: &[], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "3mf-tagged",
+ label: "3MF with face tags",
+ extensions: &["3mf"],
+ role: Role::Artifact,
+ import: None,
+ export: Some(ExportSpec { command: "file.export", format: Some("3mf-tagged"), options: &[], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "obj",
+ label: "OBJ",
+ extensions: &["obj"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Mesh, options: &[], native_only: false }),
+ export: Some(ExportSpec { command: "file.export", format: None, options: &[], scope: ExportScope::Bodies, lossless: false }),
+ },
+ FormatSpec {
+ id: "gltf",
+ label: "glTF",
+ extensions: &["glb", "gltf"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Mesh, options: &[UP_Y], native_only: false }),
+ export: None,
+ },
+ FormatSpec {
+ id: "urdf",
+ label: "URDF robot",
+ extensions: &["urdf"],
+ role: Role::Artifact,
+ import: None,
+ export: Some(ExportSpec { command: "file.export", format: None, options: URDF_OPTIONS, scope: ExportScope::Design, lossless: false }),
+ },
+ FormatSpec {
+ id: "design-json",
+ label: "Design as JSON",
+ extensions: &["json"],
+ role: Role::Design,
+ import: None,
+ export: Some(ExportSpec { command: "file.export", format: Some("json"), options: &[], scope: ExportScope::Design, lossless: true }),
+ },
+ FormatSpec {
+ id: "dxf-sketch",
+ label: "DXF drawing",
+ extensions: &["dxf"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Sketch, options: &[], native_only: false }),
+ export: None,
+ },
+ FormatSpec {
+ id: "view-dxf",
+ label: "DXF of the current view",
+ extensions: &["dxf"],
+ role: Role::Artifact,
+ import: None,
+ export: Some(ExportSpec {
+ command: "file.export_view_dxf",
+ format: None,
+ options: VIEW_DXF_OPTIONS,
+ scope: ExportScope::View,
+ lossless: false,
+ }),
+ },
+ FormatSpec {
+ id: "svg-sketch",
+ label: "SVG drawing",
+ extensions: &["svg"],
+ role: Role::Artifact,
+ import: Some(ImportSpec { target: ImportTarget::Sketch, options: &[], native_only: false }),
+ export: None,
+ },
+];
+
+/// The row with this id.
+pub fn find(id: &str) -> Option<&'static FormatSpec> {
+ FORMATS.iter().find(|f| f.id == id)
+}
+
+fn ext_of(path: &str) -> Option<String> {
+ std::path::Path::new(path).extension().and_then(|e| e.to_str()).map(str::to_ascii_lowercase)
+}
+
+/// The first row matching the path's extension, any case.
+pub fn for_path(path: &str) -> Option<&'static FormatSpec> {
+ let ext = ext_of(path)?;
+ FORMATS.iter().find(|f| f.extensions.contains(&ext.as_str()))
+}
+
+/// The first importing row matching the path's extension, any case.
+pub fn import_for_path(path: &str) -> Option<&'static FormatSpec> {
+ let ext = ext_of(path)?;
+ FORMATS.iter().find(|f| f.import.is_some() && f.extensions.contains(&ext.as_str()))
+}
+
+/// The importing rows, without the cadmpeg ones when `native` is false.
+pub fn importable(native: bool) -> impl Iterator<Item = &'static FormatSpec> {
+ FORMATS.iter().filter(move |f| f.import.as_ref().is_some_and(|i| native || !i.native_only))
+}
+
+/// The exporting rows.
+pub fn exportable() -> impl Iterator<Item = &'static FormatSpec> {
+ FORMATS.iter().filter(|f| f.export.is_some())
+}
+
+/// Every extension `doc.open` reads (designs, CAD files and meshes; not sketch drawings),
+/// without duplicates, in table order.
+pub fn open_extensions(native: bool) -> Vec<&'static str> {
+ let mut exts = Vec::new();
+ for f in importable(native) {
+ let importing = f.import.as_ref().map(|i| i.target);
+ if importing == Some(ImportTarget::Sketch) {
+ continue;
+ }
+ for e in f.extensions {
+ if !exts.contains(e) {
+ exts.push(*e);
+ }
+ }
+ }
+ exts
+}
+
+/// The Open dialog's filter groups beyond the leading "everything importable" one:
+/// (English label, lower-case extensions). Hosts add the case variants their dialogs need.
+pub fn import_filters(native: bool) -> Vec<(&'static str, Vec<&'static str>)> {
+ let mut groups: Vec<(&'static str, Vec<&'static str>)> = Vec::new();
+ let mut add = |label: &'static str, exts: &[&'static str]| {
+ if let Some((_, g)) = groups.iter_mut().find(|(l, _)| *l == label) {
+ for e in exts {
+ if !g.contains(e) {
+ g.push(e);
+ }
+ }
+ } else {
+ groups.push((label, exts.to_vec()));
+ }
+ };
+ for f in importable(native) {
+ let Some(import) = f.import.as_ref() else { continue };
+ match import.target {
+ ImportTarget::Design => add("SolidCraft design (container or JSON)", f.extensions),
+ ImportTarget::Brep if import.native_only => add("FreeCAD and Rhino", f.extensions),
+ ImportTarget::Brep => add(f.label, f.extensions),
+ ImportTarget::Mesh => add("Mesh (3MF, STL, OBJ, glTF)", f.extensions),
+ ImportTarget::Sketch => add("Sketch drawings (DXF, SVG)", f.extensions),
+ }
+ }
+ groups
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn ids_are_unique_and_extensions_lower_case() {
+ for (i, f) in FORMATS.iter().enumerate() {
+ assert!(FORMATS.iter().skip(i + 1).all(|g| g.id != f.id), "duplicate id {}", f.id);
+ assert!(!f.extensions.is_empty(), "{} has no extensions", f.id);
+ for e in f.extensions {
+ assert_eq!(*e, e.to_ascii_lowercase(), "{} extension {e} is not lower-case", f.id);
+ }
+ assert!(f.import.is_some() || f.export.is_some(), "{} neither imports nor exports", f.id);
+ }
+ }
+
+ /// The registry and the path predicates name the same extensions, so they can never
+ /// drift apart.
+ #[test]
+ fn registry_extensions_match_the_path_predicates() {
+ let with_target = |t: ImportTarget| {
+ let mut exts: Vec<&str> =
+ FORMATS.iter().filter(|f| f.import.as_ref().is_some_and(|i| i.target == t)).flat_map(|f| f.extensions.iter().copied()).collect();
+ exts.sort_unstable();
+ exts.dedup();
+ exts
+ };
+ for e in with_target(ImportTarget::Brep) {
+ assert!(crate::is_step_path(&format!("part.{e}")), "is_step_path misses .{e}");
+ }
+ for e in ["step", "stp", "igs", "iges", "fcstd", "3dm"] {
+ assert!(with_target(ImportTarget::Brep).contains(&e), "registry misses B-rep .{e}");
+ }
+ for e in with_target(ImportTarget::Mesh) {
+ assert!(crate::is_mesh_path(&format!("part.{e}")), "is_mesh_path misses .{e}");
+ }
+ for e in ["3mf", "stl", "obj", "glb", "gltf"] {
+ assert!(with_target(ImportTarget::Mesh).contains(&e), "registry misses mesh .{e}");
+ }
+ for e in with_target(ImportTarget::Design) {
+ assert!(crate::is_design_path(&format!("part.{e}")), "is_design_path misses .{e}");
+ }
+ for e in crate::DESIGN_EXTS.iter().chain(["json"].iter()) {
+ assert!(with_target(ImportTarget::Design).contains(e), "registry misses design .{e}");
+ }
+ }
+
+ /// Every export row names a format `file.export` resolves: an explicit `format` value, a
+ /// first extension [`crate::Format::from_name`] accepts, or its own command.
+ #[test]
+ fn export_rows_resolve_to_writers() {
+ for f in exportable() {
+ let Some(export) = f.export.as_ref() else { continue };
+ if export.command != "file.export" {
+ continue;
+ }
+ let name = export.format.unwrap_or(f.extensions[0]);
+ assert!(crate::Format::from_name(name).is_ok(), "{}: file.export does not resolve {name}", f.id);
+ }
+ }
+
+ #[test]
+ fn paths_resolve_to_the_canonical_rows() {
+ assert_eq!(for_path("a.SolidCraft").map(|f| f.id), Some("design"));
+ assert_eq!(for_path("a.json").map(|f| f.id), Some("design"));
+ assert_eq!(for_path("a.STEP").map(|f| f.id), Some("step"));
+ assert_eq!(for_path("a.3mf").map(|f| f.id), Some("3mf"));
+ assert_eq!(for_path("a.dxf").map(|f| f.id), Some("dxf-sketch"));
+ assert_eq!(import_for_path("a.glb").map(|f| f.id), Some("gltf"));
+ assert!(for_path("a.png").is_none());
+ assert!(for_path("nodot").is_none());
+ }
+
+ #[test]
+ fn wasm_filtering_hides_the_cadmpeg_rows() {
+ assert!(importable(true).any(|f| f.id == "fcstd"));
+ assert!(importable(false).all(|f| f.id != "fcstd" && f.id != "3dm"));
+ assert!(!open_extensions(false).contains(&"fcstd"));
+ assert!(open_extensions(false).contains(&"igs"));
+ }
+
+ /// The Open dialog's groups, as the hosts show them.
+ #[test]
+ fn import_filter_groups_hold_the_expected_extensions() {
+ let native = import_filters(true);
+ let find = |label: &str| native.iter().find(|(l, _)| *l == label).map(|(_, e)| e.clone()).unwrap_or_default();
+ assert_eq!(find("SolidCraft design (container or JSON)"), vec![crate::DESIGN_EXT, crate::LEGACY_DESIGN_EXT, "json"]);
+ assert_eq!(find("STEP"), vec!["step", "stp"]);
+ assert_eq!(find("IGES"), vec!["igs", "iges"]);
+ assert_eq!(find("FreeCAD and Rhino"), vec!["fcstd", "3dm"]);
+ assert_eq!(find("Mesh (3MF, STL, OBJ, glTF)"), vec!["stl", "3mf", "obj", "glb", "gltf"]);
+ assert_eq!(find("Sketch drawings (DXF, SVG)"), vec!["dxf", "svg"]);
+ assert!(import_filters(false).iter().all(|(l, _)| *l != "FreeCAD and Rhino"));
+ }
+}
diff --git a/crates/io/src/lib.rs b/crates/io/src/lib.rs
index 5ab6ca9df3..d1ac121913 100644
--- a/crates/io/src/lib.rs
+++ b/crates/io/src/lib.rs
@@ -11,6 +11,7 @@ mod design;
mod design_metadata;
mod dxf;
mod dxf_out;
+pub mod formats;
pub use design::{
DesignCompression, DesignContainerReader, DesignPreview, THUMBNAIL_SIZE, is_design_container, read_design_file, read_design_geometry,
read_design_preview, read_design_thumbnail, read_design_thumbnail_file, write_design_container, write_design_container_with_cache,
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index c65a550ddf..a1e4f73e48 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -955,7 +955,7 @@ impl SolveApp {
// inserted the way Insert STEP or Insert Mesh would (#1240).
self.pick_open(|app, path| {
let Some(path) = path else { return };
- if is_design_path(&path) {
+ if solidcraft_engine::io::is_design_path(&path) {
if app.run("component.insert_design", json!({ "path": path })).is_ok() {
app.fit_view();
}
@@ -1894,10 +1894,3 @@ pub fn now_ms() -> f64 {
mod picker_test_support;
#[cfg(test)]
mod test_support;
-
-/// A SolidCraft design file (`.solidcraft`, or a design saved as JSON), as opposed to a STEP or
-/// mesh file.
-fn is_design_path(path: &str) -> bool {
- let ext = std::path::Path::new(path).extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
- matches!(ext.as_str(), "solidcraft" | "solvecraft" | "json")
-}