cadcode 0.1.0 → 0.2.0

package/README.md

@@ -61,6 +61,7 @@ cadcode png case.js --part assembly --view sheet --size 1600x1200
 - **Zoom**: mouse wheel
 - **Fit the model to the view**: F, or the Fit button
 - **Switch parts**: the part dropdown
+- **Download the part as STL**: the STL button. It is the same file `cadcode stl` writes.
 
 Errors appear in the page and in the terminal, with the line in your file. The last good model stays on screen until you fix them. Whatever the program prints with `console.log` appears in the corner of the page.
 

package/client/index.html

@@ -33,6 +33,9 @@
         <button id="fit" type="button" title="Fit model to view (F)">
           Fit
         </button>
+        <button id="download" type="button" title="Download the part as STL">
+          STL
+        </button>
       </header>
 
       <section id="logs" class="logs" hidden></section>

package/client/viewer.css

@@ -112,6 +112,11 @@ button {
   cursor: pointer;
 }
 
+button:disabled {
+  cursor: progress;
+  opacity: 0.55;
+}
+
 button:hover,
 select:hover {
   border-color: rgba(20, 30, 40, 0.28);

package/client/viewer.js

@@ -246,6 +246,29 @@ function showParts(names, current) {
   partSelect.replaceChildren(...names.map((name) => new Option(name, name, false, name === current)));
 }
 
+// --- Download ----------------------------------------------------------------
+// Fetched rather than navigated to, so a failing program shows its error here
+// instead of replacing the viewer.
+
+const downloadButton = document.getElementById('download');
+
+downloadButton.addEventListener('click', async () => {
+  downloadButton.disabled = true;
+  try {
+    const response = await fetch(`/stl?part=${encodeURIComponent(partSelect.value)}`);
+    if (!response.ok) throw new Error(await response.text());
+    const link = document.createElement('a');
+    link.href = URL.createObjectURL(await response.blob());
+    link.download = response.headers.get('Content-Disposition').match(/filename="(.+)"/)[1];
+    link.click();
+    setTimeout(() => URL.revokeObjectURL(link.href)); // after the browser has started the download
+  } catch (error) {
+    showError(`STL download failed: ${error.message}`);
+  } finally {
+    downloadButton.disabled = false;
+  }
+});
+
 // --- Connection --------------------------------------------------------------
 
 let socket = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cadcode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "scripts": {
     "test": "node --test \"test/*.test.js\""
   },

package/src/dev/server.js

@@ -63,6 +63,7 @@ function openBrowser(url) {
 export async function startDevServer({ file, port, host, part, overrides, open }) {
   const relative = path.relative(process.cwd(), path.resolve(file));
   const displayName = relative.startsWith('..') ? path.resolve(file) : relative;
+  const baseName = path.basename(file).replace(/\.[^.]+$/, '');
   // lastError is replayed to browsers that connect while the program is broken.
   const state = { part, lastFrame: null, lastError: null, worker: null, bundle: null };
   const sockets = new Set();
@@ -102,6 +103,22 @@ export async function startDevServer({ file, port, host, part, overrides, open }
     });
   }
 
+  // A download evaluates in its own worker, so it never cancels or waits for the preview.
+  function downloadSTL(res, part) {
+    if (!state.bundle) return void res.writeHead(503, { 'Content-Type': 'text/plain' }).end('The program has not built yet');
+    const worker = new Worker(WORKER_URL, { workerData: { bundle: state.bundle, part, overrides, output: 'stl' } });
+    const fail = (message) => res.writeHead(500, { 'Content-Type': 'text/plain' }).end(message);
+    worker.once('message', (result) => {
+      worker.terminate();
+      if (!result.ok) return fail(result.message);
+      const name = result.partNames.length > 1 ? `${baseName}-${result.part}.stl` : `${baseName}.stl`;
+      res.writeHead(200, { 'Content-Type': 'model/stl', 'Content-Disposition': `attachment; filename="${name}"` });
+      res.end(Buffer.from(result.stl.buffer, result.stl.byteOffset, result.stl.byteLength));
+      console.log(`↓ ${name}`);
+    });
+    worker.once('error', (error) => fail(error.message));
+  }
+
   const options = bundleOptions(file);
   const ctx = await esbuild.context({
     ...options,
@@ -127,6 +144,7 @@ export async function startDevServer({ file, port, host, part, overrides, open }
   const server = http.createServer((req, res) => {
     const url = new URL(req.url ?? '/', 'http://localhost');
     if (url.pathname === '/') return serveFile(res, CLIENT_DIR, 'index.html');
+    if (url.pathname === '/stl') return downloadSTL(res, url.searchParams.get('part') ?? state.part);
     if (url.pathname.startsWith('/vendor/three/')) return serveFile(res, THREE_DIR, url.pathname.slice('/vendor/three/'.length));
     serveFile(res, CLIENT_DIR, url.pathname.slice(1));
   });

package/src/dev/worker.js

@@ -1,10 +1,12 @@
-// Evaluates a program in a worker thread. Each evaluation gets a fresh worker:
+// Evaluates a program in a worker thread, for the viewer's meshes or, with
+// output 'stl', for a download. Each evaluation gets a fresh worker:
 // that frees all WASM memory between runs, resets library state such as
 // setResolution(), and lets the server kill a run that a newer save made stale.
 import { parentPort, workerData } from 'node:worker_threads';
 import { format } from 'node:util';
 import { evaluateProgram } from '../core/program.js';
 import { meshGroups } from '../core/mesh.js';
+import { toSTL } from '../export/stl.js';
 
 // Bundles carry inline source maps; this makes stack traces point at the user's files.
 process.setSourceMapsEnabled(true);
@@ -18,22 +20,27 @@ for (const level of ['log', 'info', 'warn', 'error']) {
   };
 }
 
-const { bundle, part, overrides } = workerData;
+const { bundle, part, overrides, output } = workerData;
 const started = performance.now();
 try {
-  const result = await evaluateProgram(bundle, { part, overrides, fallbackToFirst: true });
-  const groups = meshGroups(result.solids);
-  parentPort.postMessage(
-    {
-      ok: true,
-      partNames: result.partNames,
-      part: result.part,
-      groups,
-      logs,
-      ms: Math.round(performance.now() - started),
-    },
-    groups.flatMap((g) => [g.positions.buffer, g.indices.buffer]),
-  );
+  const result = await evaluateProgram(bundle, { part, overrides, fallbackToFirst: output !== 'stl' });
+  if (output === 'stl') {
+    const stl = toSTL(result.solids);
+    parentPort.postMessage({ ok: true, partNames: result.partNames, part: result.part, stl }, [stl.buffer]);
+  } else {
+    const groups = meshGroups(result.solids);
+    parentPort.postMessage(
+      {
+        ok: true,
+        partNames: result.partNames,
+        part: result.part,
+        groups,
+        logs,
+        ms: Math.round(performance.now() - started),
+      },
+      groups.flatMap((g) => [g.positions.buffer, g.indices.buffer]),
+    );
+  }
 } catch (error) {
   parentPort.postMessage({ ok: false, message: error?.message ?? String(error), stack: error?.stack, logs });
 }