@rulecad/cad 0.3.1 → 0.3.3

package/README.md

@@ -69,6 +69,9 @@ fragment, which never reaches the web host, so the public page can open private
 which version it holds (`keyboard/keycap@0.1.0`, or `+changes` if it isn't a release). The page is to become `@rulecad/viewer`;
 `scripts/publish-view.sh "message"` publishes it (only that folder) to the public repo.
 
+- **Rules:** a link carries the model's values and the rules they use (value, source, kind, date checked) for the
+  page's Rules panel; estimates are marked there. A rule set with `"private": true` stays out of links, and
+  `--no-rules` leaves the list out altogether. Anyone with a link can read what it carries.
 - **Short links** (`--short`, and the default for `--md`, once `"shorten": "gist"` is in `cad.config.json`'s
   `targets`): the link's data goes in a secret GitHub Gist (unlisted, but anyone with the link can open it) and the
   link carries only its ID: `…/#s=<id>`. The page fetches it from GitHub's API. The same model reuses its Gist

package/bin/cad.mjs

@@ -12,7 +12,7 @@ import { git, tags, bump, bigger, newer, compare, snapshot, materialise, files,
 import { check } from '@rulecad/printcheck';
 import { preview } from '../lib/preview.mjs';
 import { isAssembly, buildAssembly, checkAssembly, shapes } from '../lib/assembly.mjs';
-import { fromParts, fromShapes, encode } from '@rulecad/model-link';
+import { fromParts, fromShapes, encode, check as checkLink, expand } from '@rulecad/model-link';
 import { threemf, slotOf } from '../lib/threemf.mjs';
 
 // The project's filaments: { base: { slot: 1, … }, legend: { slot: 2, … } } in project.json
@@ -31,6 +31,12 @@ function filamentNotes(parts, fil) {
 const openInSlicer = (f) => (process.platform === 'darwin' ? execFileSync('open', ['-a', 'Bambu Studio', f])
   : execFileSync(process.platform === 'win32' ? 'explorer' : 'xdg-open', [f]));
 const VIEW = process.env.CAD_VIEW_URL || config.viewUrl;
+// A link to the model page; one the page would turn away is an error here, not when someone opens it
+async function linkTo(model) {
+  const errors = checkLink(model.shapes ? expand(model) : model);
+  if (errors.length) throw new Error(`no link: ${errors[0]}`);
+  return `${VIEW}#m=${await encode(model)}`;
+}
 
 const HELP = `cad: JSCAD designs you can trace, check, share and print (rulecad)
 
@@ -45,6 +51,7 @@ const HELP = `cad: JSCAD designs you can trace, check, share and print (rulecad)
   cad link <project>/<object>       links to open the model in a browser, and to download its STL or 3MF
                                     [--md: one labelled Markdown link, for chat (the page downloads any parts): short unless --long]
                                     [--short: the model's data in a secret GitHub Gist, so links are ~80 characters]
+                                    [--no-rules: leave out the Rules panel's list of values and their sources]
 
   cad status [project]              each object's version, and whether it has changes since its last release
   cad release <project>/<object> -m "what changed" [--bump major|minor|patch] [--dry-run] [--push]
@@ -264,6 +271,7 @@ async function assembly(cmd, ref) {
     const model = {
       title, version: versions, src: `${s.project}/${s.name}`, // object versions are in version: the file name stays short orientation: a.note || (a.kind === 'plate' ? 'A print plate: print everything together.' : 'A fit check: references are faint.'),
       rules: [],
+      ...sheet([...new Map(s.objects.filter((o) => o.built?.entries).map((o) => [o.objName, o.built.entries])).entries()]),
       // Its boards' 2D views (copper, schematic), so one link holds the whole build: tabs over the 3D model
       ...(await (async () => {
         const boards = [...new Map(s.objects.filter((o) => o.built?.circuit).map((o) => [o.objName, o])).values()];
@@ -278,7 +286,7 @@ async function assembly(cmd, ref) {
         return placed.place.map(([i, ...m], n) => { const p = placed.shapes[i].part; return { shape: i, role: p.role, label: p.object || p.label, slot: slotOf(fil, p.filament), triangles: tri(placed.shapes[i].triangles), matrix: m, name: s.parts[n].name }; });
       })() : []),
     };
-    const url = `${VIEW}#m=${await encode(model)}`;
+    const url = await linkTo(model);
     return { view: url, stl: `${url}&get=stl`, '3mf': `${url}&get=3mf`, src: model.src, size: url.length, title, version: '' };
   };
   if (cmd === 'link') return await printLinks(await link());
@@ -297,6 +305,23 @@ async function assembly(cmd, ref) {
 }
 
 // ---------- links ----------
+// The rules sheet a link carries, for the page's Rules panel: a row for each of an object's own values, then each rule
+// they use, as [group, name, value, unit, rule, expr, kind, source, checked] (group: the object, or the rule's set).
+// A rule set marked "private" stays out, and --no-rules leaves the sheet out altogether.
+function sheet(objects) {
+  if (opt('no-rules')) return {};
+  const rows = [], seen = new Set(), trim = (r) => { while (r.length && (r[r.length - 1] === '' || r[r.length - 1] == null)) r.pop(); return r; };
+  for (const [obj, entries] of objects) for (const e of entries) {
+    if (!e.name.includes('.')) rows.push(trim([obj, e.label || e.name, fmt(e.value), e.unit || '', e.rule || '', e.expr || '']));
+  }
+  for (const [, entries] of objects) for (const e of entries) {
+    if (!e.name.includes('.') || !e.used || e.private || seen.has(e.name)) continue;
+    seen.add(e.name);
+    const [set, name] = e.name.split('.');
+    rows.push(trim([set, name, fmt(e.value), e.unit || '', e.rule || '', e.expr || '', e.kind || '', e.source || '', e.checked || '']));
+  }
+  return rows.length ? { sheet: rows } : {};
+}
 // The model as a link: full print precision (triangles), the rules card, and exactly which version it is.
 async function links(d, b, set) {
   const s = d.tag ? { kind: null } : await since(d), fil = filaments(d.project);
@@ -306,10 +331,11 @@ async function links(d, b, set) {
     title: `${b.object.title || b.object.name}${d.variant ? ` (${d.variant})` : ''}`, version, src, ...(Object.keys(set).length ? { set: suffix(set).slice(1).replace(/-(?=\w+=)/g, ',') } : {}),
     material: b.object.material, orientation: b.object.orientation,
     rules: b.entries.filter((e) => e.show).map((e) => [e.label || e.name, fmt(e.value), e.unit || '']),
+    ...sheet([[b.object.name, b.entries]]),
     ...(b.circuit ? { views: await (await pcbEngine()).views(b.circuit) } : {}), // boards: the 2D board and schematic
     ...fromParts(b.parts.map((p) => ({ name: p.name, role: p.role, label: p.label, slot: slotOf(fil, p.filament), triangles: p.triangles.flatMap((t) => t.slice(1, -1).map((_, i) => [t[0], t[i + 1], t[i + 2]])) }))),
   };
-  const url = `${VIEW}#m=${await encode(model)}`;
+  const url = await linkTo(model);
   return { view: url, stl: `${url}&get=stl`, '3mf': `${url}&get=3mf`, src, size: url.length, title: model.title, version };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rulecad/cad",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "The cad command: JSCAD designs from traceable rules, checked for printing and fit, versioned by what fits, shared as links and exported as Bambu 3MF.",
   "type": "module",
   "bin": {
@@ -43,11 +43,11 @@
     "directory": "packages/cad"
   },
   "dependencies": {
-    "@rulecad/variables": "^0.1.4",
+    "@rulecad/variables": "^0.1.6",
     "@rulecad/keyboard-layout": "^0.1.2",
     "@rulecad/printcheck": "^0.1.0",
     "@rulecad/fit": "^0.2.0",
-    "@rulecad/model-link": "^0.1.2",
+    "@rulecad/model-link": "^0.1.5",
     "@rulecad/versions": "^0.1.0",
     "@rulecad/shapes": "^0.2.0",
     "@rulecad/rules": "^0.2.0",