@bobfrankston/wallplater 1.0.3 → 1.0.4

package/README.md

@@ -14,20 +14,39 @@ individually colourable objects) or per-part STLs.
 The manifold engine has no system dependency beyond Node and is the path
 forward; `-scad` is kept for parity/verification.
 
+## Build / install
+
+TypeScript compiled to co-located `.js` / `.d.ts` / `.map` (no `src`/`dist`
+split). `tsc` is the global install.
+
+```sh
+npm install
+npm run build        # tsc  (or: npm run watch  for tsc -w)
+```
+
+Installed globally (`npm i -g @bobfrankston/wallplater`) it exposes a
+`wallplater` command. `defaults.json` is resolved relative to the module, so it
+runs correctly from any working directory.
+
 ## Usage
 
-Requires Node 24+ (native TypeScript + ESM — run `.ts` directly). `tsc` is the
-global install; `npm run typecheck` runs `tsc --noEmit` (type-check only — this
-project runs `.ts` and never emits `.js`).
+Requires Node 24+ (ESM). Run the compiled entry:
 
 ```sh
-node index.ts ../KitchenBack.json            # manifold engine -> KitchenBack.3mf
-node index.ts ../KitchenBack.json -scad      # OpenSCAD engine (same result)
+node index.js ../KitchenBack.json          # manifold engine -> KitchenBack.3mf
+node index.js ../KitchenBack.json -scad    # OpenSCAD engine (same result)
+wallplater   ../KitchenBack.json           # if installed globally
 ```
 
 - Outputs are written next to the **config file**, named after the config's `name`.
 - Unknown flags are rejected. `-scad` (or `--scad`) selects the OpenSCAD engine.
 
+The 3MF holds up to three named, individually-selectable objects — `<name> plate`,
+`<name> labels` (all accent text), `<name> breaker` — so each is easy to find in
+Bambu Studio's object list and assign to a filament. The label objects sit flush
+in the plate's front-face pockets (the plate prints front-face-down), so they
+look hidden until you give them a second colour.
+
 ## Config
 
 Each specific config is **deep-merged over `defaults.json`** (in this
@@ -80,8 +99,8 @@ opening is unchanged — only the labelling differs. Per gang:
 ```
 
 Rockers are spaced evenly down the opening; `left` labels are right-aligned snug
-to the opening, `right` labels left-aligned. `legend` / `header` / `rockers`
-all print in the accent colour (the `legend` object). Relevant defaults:
+to the opening, `right` labels left-aligned. `legend` / `header` / `rockers` /
+per-gang `breaker` all print in the accent colour (the **labels** object). Relevant defaults:
 `rockerSize` (3.5mm), `rockerGap` (1.5mm), `headerSize` (4mm), `headerGap`
 (5mm). Keep side labels short on multi-gang plates — the side margin is ~18 mm
 on an end/single gang but only ~6 mm between interior gangs; long labels can

package/index.js

@@ -18,6 +18,10 @@ import { loadConfig } from "./config.js";
 import { generateScad, runOpenscad, readStl } from "./scad.js";
 import { buildMeshes } from "./geometry.js";
 import { build3mf, writeBinaryStl } from "./threemf.js";
+// Bambu object-list name: "<config> <part>"; the accent text object reads "labels".
+function partName(cfgName, label) {
+    return `${cfgName} ${label === "legend" ? "labels" : label}`;
+}
 function partList(cfg) {
     const parts = [{ mode: "plate", label: "plate" }];
     if (cfg.gangs.some((g) => (g.legend ?? "") !== ""))
@@ -41,16 +45,16 @@ function runScadEngine(cfg, dir) {
     }
     else {
         const tmp = [];
-        const meshes = parts.map((p) => {
+        const objects = parts.map((p) => {
             const stl = join(dir, `_${cfg.name}_${p.label}.stl`);
             runOpenscad(cfg.openscad, scadPath, stl, p.mode);
             tmp.push(stl);
-            return readStl(stl);
+            return { name: partName(cfg.name, p.label), mesh: readStl(stl) };
         });
-        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(meshes));
+        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(objects));
         for (const t of tmp)
             unlinkSync(t);
-        console.log("  wrote", `${cfg.name}.3mf`, `(${meshes.length} objects: ${parts.map((p) => p.label).join(", ")})`);
+        console.log("  wrote", `${cfg.name}.3mf`, `(${objects.length} objects: ${objects.map((o) => o.name).join(", ")})`);
     }
 }
 async function runManifoldEngine(cfg, dir) {
@@ -66,8 +70,9 @@ async function runManifoldEngine(cfg, dir) {
             writeFileSync(join(dir, `${cfg.name}_${m.label}.stl`), writeBinaryStl(m.mesh));
     }
     else {
-        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(meshes.map((m) => m.mesh)));
-        console.log("  wrote", `${cfg.name}.3mf`, `(${meshes.length} objects: ${meshes.map((m) => m.label).join(", ")})`);
+        const objects = meshes.map((m) => ({ name: partName(cfg.name, m.label), mesh: m.mesh }));
+        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(objects));
+        console.log("  wrote", `${cfg.name}.3mf`, `(${objects.length} objects: ${objects.map((o) => o.name).join(", ")})`);
     }
 }
 async function main() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/wallplater",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "type": "module",
   "description": "JSON-driven wall-plate generator (Decora / duplex / blank). Direct-to-3MF via manifold-3d, with an optional OpenSCAD engine.",
   "main": "index.js",

package/threemf.d.ts

@@ -2,6 +2,10 @@ export interface Mesh {
     verts: number[][];
     tris: number[][];
 }
-export declare function build3mf(meshes: Mesh[]): Buffer;
+export interface Object3mf {
+    name: string;
+    mesh: Mesh;
+}
+export declare function build3mf(objects: Object3mf[]): Buffer;
 export declare function writeBinaryStl(mesh: Mesh): Buffer;
 //# sourceMappingURL=threemf.d.ts.map

package/threemf.js

@@ -6,17 +6,22 @@
  *   - writeBinaryStl(): a single binary STL (used for the manifold STL path).
  */
 import { deflateRawSync } from "zlib";
+function xmlEscape(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
 // ---------- multi-object 3MF (core spec, no slicer settings) ----------
-export function build3mf(meshes) {
-    // separate top-level objects (each individually colourable in Bambu), all
-    // at the same transform so the labels stay seated in the plate's pockets.
+export function build3mf(objects) {
+    // separate, named top-level objects (each individually selectable/colourable
+    // in Bambu), all at the same transform so the labels stay seated in the
+    // plate's pockets.
     let objs = "";
     let items = "";
-    meshes.forEach((m, i) => {
+    objects.forEach((o, i) => {
+        const m = o.mesh;
         const id = i + 1;
         const vs = m.verts.map((v) => `<vertex x="${v[0]}" y="${v[1]}" z="${v[2]}"/>`).join("");
         const ts = m.tris.map((t) => `<triangle v1="${t[0]}" v2="${t[1]}" v3="${t[2]}"/>`).join("");
-        objs += `  <object id="${id}" type="model"><mesh><vertices>${vs}</vertices><triangles>${ts}</triangles></mesh></object>\n`;
+        objs += `  <object id="${id}" type="model" name="${xmlEscape(o.name)}"><mesh><vertices>${vs}</vertices><triangles>${ts}</triangles></mesh></object>\n`;
         items += `  <item objectid="${id}" transform="1 0 0 0 1 0 0 0 1 128 128 0"/>\n`;
     });
     const model = `<?xml version="1.0" encoding="UTF-8"?>