fix(assimp): pass -f<format> so non-extension targets work (#557)

* fix(assimp): pass -f<format> so non-extension targets work

The assimp converter invokes `assimp export <in> <out>` and relies on
assimp's extension-based format inference to pick the output format.
That works for targets whose id happens to match a real file extension
(glb, gltf, obj, stl, ply, etc.) but silently fails for every target
whose assimp id is not a conventional filename extension:

  glb2, gltf2, objnomtl, stlb, plyb, fbxa, assbin, assxml, pbrt, assjson

Picking any of those in the UI aborts the job with:

  assimp export: no output format specified and I failed to guess it

assimp_cmd's `-f<h>` flag overrides extension inference, and the values
in `properties.to.object` already correspond 1:1 to assimp's format ids
(verified against `assimp listexport`). Passing `-f${convertTo}` makes
every advertised target work without changing anything else.

Reproduction: upload any .stl, convert to glb2. Before: ENOENT on the
nonexistent output file. After: valid binary glTF 2.0.

* fix(assimp): write real file extensions for non-extension format ids

Follow-up to the previous commit. With `-f<format>` now passed to
assimp, every advertised target exports successfully — but seven of
them still produce files with assimp's internal format id as the
extension, which no third-party viewer recognises:

  glb2 → .glb2   (really binary glTF 2.0, should be .glb)
  gltf2 → .gltf2 (text glTF 2.0, should be .gltf)
  objnomtl → .objnomtl   (OBJ without .mtl, should be .obj)
  stlb → .stlb   (binary STL, should be .stl)
  plyb → .plyb   (binary PLY, should be .ply)
  fbxa → .fbxa   (ASCII FBX, should be .fbx)
  assjson → .assjson   (JSON dump, should be .json)

Map these in `normalizeOutputFiletype`, the same helper that already
handles jpeg→jpg, latex→tex, markdown→md. The format id on `convertTo`
is untouched, so `assimp -f<id>` still selects the correct
encoding/variant — only the output filename changes.

assbin, assxml, and pbrt are both the format id and the canonical
extension, so they need no mapping.

* style(assimp): fix prettier formatting

src/converters/assimp.ts

@@ -121,20 +121,24 @@ export async function convert(
   execFile: ExecFileFn = execFileOriginal, // to make it mockable
 ): Promise<string> {
   return new Promise((resolve, reject) => {
-    execFile("assimp", ["export", filePath, targetPath], (error, stdout, stderr) => {
-      if (error) {
-        reject(`error: ${error}`);
-      }
+    execFile(
+      "assimp",
+      ["export", filePath, targetPath, `-f${convertTo}`],
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(`error: ${error}`);
+        }
 
-      if (stdout) {
-        console.log(`stdout: ${stdout}`);
-      }
+        if (stdout) {
+          console.log(`stdout: ${stdout}`);
+        }
 
-      if (stderr) {
-        console.error(`stderr: ${stderr}`);
-      }
+        if (stderr) {
+          console.error(`stderr: ${stderr}`);
+        }
 
-      resolve("Done");
-    });
+        resolve("Done");
+      },
+    );
   });
 }

src/helpers/normalizeFiletype.ts

@@ -31,6 +31,24 @@ export const normalizeOutputFiletype = (filetype: string): string => {
     case "markdown_mmd":
     case "markdown":
       return "md";
+    // assimp format ids that aren't real file extensions — map to the
+    // canonical extension for the underlying format so the output file
+    // opens in third-party viewers. The format id is still passed to
+    // `assimp export -f<id>` so the right encoding/variant is produced.
+    case "glb2":
+      return "glb";
+    case "gltf2":
+      return "gltf";
+    case "objnomtl":
+      return "obj";
+    case "stlb":
+      return "stl";
+    case "plyb":
+      return "ply";
+    case "fbxa":
+      return "fbx";
+    case "assjson":
+      return "json";
     default:
       return lowercaseFiletype;
   }