@reekon-tools/boldr-cad 1.7.0 → 1.8.0

package/src/tools/dim.ts

@@ -24,7 +24,7 @@ import { addOpeningDim } from './openings';
 import type { PEv } from './registry';
 import { keypadFresh, keypadOpen, keypadSetReading } from '../editor/keypad';
 import { advanceAfterReading } from '../editor/advance';
-import { cornerLines } from '../editor/selection';
+import { cornerLines, edgePair, selInfo } from '../editor/selection';
 import { closeKeypad, kpTyped, openKeypad, showConflict, toast, updateCtx, updateHint, type KeypadSpec } from '../editor/ports';
 import { noScaleYet, pendingLabel, startingValue } from '../editor/scaleGate';
 
@@ -165,7 +165,7 @@ export function dimLine(lid: string, side?: 1 | -1): void {
   const wall = faced(sk, lid);
   const ex = lengthDimOf(sk, lid);
   if (ex) { editDim(ex, undefined, false, wall && side ? { face: side } : undefined); return; }
-  let face: 0 | 1 | -1 = wall ? side ?? defaultFace(sk, lid, ed.wallTap?.id === lid ? ed.wallTap.side : undefined) ?? 0 : 0;
+  let face: 0 | 1 | -1 = wall ? firstFace(sk, lid, side) : 0;
   const len = () => (face ? faceLength(sk, lid, face) : lineLen(sk, l));
   // (while it's being entered, what it measures is what's highlighted: the edge, or the wall)
   const was = ed.sel;
@@ -196,7 +196,7 @@ export function dimLine(lid: string, side?: 1 | -1): void {
   /** The line's length dimension, driving, measured where the keypad says (`extra`: what it's from). Whether it took. */
   function addLength(v: number, extra: Partial<Constraint>): boolean {
     pushHistory();
-    const r = tryAddConstraint({ type: 'dist', a: l.a, b: l.b, kind: 'al', value: v, line: lid, driving: true, off: face ? (face * 30) / V().s : 0, ...(face ? { face } : {}), ...extra });
+    const r = tryAddConstraint({ ...lengthDim(sk, lid, face), value: v, ...extra });
     // a measurement of the job drives a line, or nothing: not one whose length the drawing already sets
     let took = r.ok;
     if (r.ok && r.ref && extra.measurementRef) {
@@ -383,9 +383,102 @@ export function dimEdgePoint(lid: string, side: 1 | -1, p: string): void {
   const sk = SK(), l = sk.lines[lid];
   // (one of the wall's own ends is no distance from it)
   if (!l || p === l.a || p === l.b) { toast('Pick a point off the wall to measure from its edge.', { warn: true }); return; }
-  dimPointLine(p, lid, { faces: [faceToward(sk, lid, sk.points[p], side), 0], title: 'Distance from the edge' });
+  dimPointLine(p, lid, { faces: edgePointFaces(sk, lid, side, p), title: 'Distance from the edge' });
 }
 
+/** From a wall's edge to a point: measured from that face of the wall. */
+const edgePointFaces = (sk: Sketch, lid: string, side: 1 | -1, p: string): [number, number] => [faceToward(sk, lid, sk.points[p], side), 0];
+
+/* What the + measures, as a dimension not made yet: the builders above make these, and the grey number shows them. */
+
+/**
+ * The face a wall's length (a curved wall's diameter) is first measured on: `side`, the edge picked; picked whole, the
+ * side a space is on (the side it was tapped on, between two); its centreline with no space beside it.
+ */
+const firstFace = (sk: Sketch, id: string, side?: 1 | -1): 0 | 1 | -1 =>
+  side ?? defaultFace(sk, id, ed.wallTap?.id === id ? ed.wallTap.side : undefined) ?? 0;
+
+/** Line `lid`'s length, measured on `face` (a wall's; 0 along the line). Its label sits off the side it's measured on. */
+function lengthDim(sk: Sketch, lid: string, face: 0 | 1 | -1): Constraint {
+  const l = sk.lines[lid];
+  return { type: 'dist', a: l.a, b: l.b, kind: 'al', line: lid, driving: true, off: face ? (face * 30) / V().s : 0, ...(face ? { face } : {}) };
+}
+
+/** A circle's or arc's diameter, across `face` (a curved wall's; 0 its centreline). */
+const diamDim = (id: string, face: 0 | 1 | -1): Constraint => ({ type: 'diam', c: id, driving: true, ...(face ? { face } : {}) });
+
+/** A circle's or arc's diameter dimension, if it has one. */
+const diamDimOf = (sk: Sketch, id: string): string | undefined => Object.keys(sk.cons).find(k => sk.cons[k].type === 'diam' && sk.cons[k].c === id);
+
+/** The angle between two lines. */
+const angleDim = (l1: string, l2: string): Constraint => ({ type: 'angle', l1, l2, value: 0, driving: true });
+
+/** The straight distance between two points. */
+const pointsDim = (a: string, b: string): Constraint => ({ type: 'dist', a, b, kind: 'al', driving: true, off: 0 });
+
+/**
+ * Point `p`'s distance from line `lid`, square to it, on its side of it. On a wall, from `faces[0]` (see dimPointLine) —
+ * by default the face toward the point where a space is against it; `l2`, the wall the point is the end of.
+ */
+function pointLineDim(sk: Sketch, p: string, lid: string, opts: { faces?: [number, number]; l2?: string } = {}): Constraint {
+  const l = sk.lines[lid], P = sk.points[p], A = sk.points[l.a], B = sk.points[l.b];
+  const sd = ((B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x)) / (hyp(B.x - A.x, B.y - A.y) || 1);
+  const c: Constraint = { type: 'pldist', p, l: lid, value: 0, sign: sd < 0 ? -1 : 1, driving: true, ...(opts.l2 ? { l2: opts.l2 } : {}) };
+  applyFace(c, { faces: opts.faces ?? [faceToward(sk, lid, P), 0] });
+  return c;
+}
+
+/**
+ * What the yellow + measures for the selection, as the dimension it would make (`c`, its value unset), with the one
+ * already there for it (`existing`), which the + edits instead. Null where it makes no dimension of the plan: nothing it
+ * measures, a door's or window's sizes (their own dimensions), a wall's thickness, the wall view (wallPlus).
+ */
+export function selectionDim(): { c: Constraint; existing?: string } | null {
+  const sk = SK(), s = selInfo();
+  if (s.dims.length || s.odims.length || s.openings.length || s.oanchors.length) return null;
+  if (s.wfaces.length === 1 && s.n === 1) {
+    const [id, side] = edgeOf(s.wfaces[0]);
+    if (sk.lines[id]) return { c: lengthDim(sk, id, side), existing: lengthDimOf(sk, id) ?? undefined };
+    return { c: diamDim(id, side), existing: diamDimOf(sk, id) };
+  }
+  if (edgePair(s)) {
+    const edges = s.wfaces.map(edgeOf), other = ed.sel.find(x => x.type !== 'wface');
+    if (edges.length === 2) {
+      const [[a, sa], [b, sb]] = edges;
+      return a !== b && sk.lines[a] && sk.lines[b] ? twoLinesDim(sk, a, b, { [a]: sa, [b]: sb }) : null;
+    }
+    const [lid, side] = edges[0], l = sk.lines[lid];
+    if (other?.type === 'line') return twoLinesDim(sk, lid, other.id, { [lid]: side });
+    if (other?.type !== 'point' || !l || other.id === l.a || other.id === l.b) return null;
+    return { c: pointLineDim(sk, other.id, lid, { faces: edgePointFaces(sk, lid, side, other.id) }), existing: pointLineDimOf(sk, other.id, lid) };
+  }
+  if (s.lines.length === 1 && s.n === 1) {
+    const lid = s.lines[0];
+    return { c: lengthDim(sk, lid, faced(sk, lid) ? firstFace(sk, lid) : 0), existing: lengthDimOf(sk, lid) ?? undefined };
+  }
+  if (s.curves.length === 1 && s.n === 1) {
+    const id = s.curves[0];
+    return { c: diamDim(id, wallOf(sk, id) ? firstFace(sk, id) : 0), existing: diamDimOf(sk, id) };
+  }
+  if (s.points.length === 1 && s.n === 1) return cornerDim(sk, s.points[0]);
+  if (s.n === 2 && s.lines.length === 2) return twoLinesDim(sk, s.lines[0], s.lines[1]);
+  if (s.n === 2 && s.points.length === 2) {
+    const [a, b] = s.points;
+    const existing = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'dist' && !c.line && ((c.a === a && c.b === b) || (c.a === b && c.b === a)); });
+    return { c: pointsDim(a, b), existing };
+  }
+  if (s.n === 2 && s.points.length === 1 && s.lines.length === 1) {
+    const [p] = s.points, [lid] = s.lines, l = sk.lines[lid];
+    // (one of the line's own ends is no distance from it)
+    if (!l || p === l.a || p === l.b) return null;
+    return { c: pointLineDim(sk, p, lid), existing: pointLineDimOf(sk, p, lid) };
+  }
+  return null;
+}
+
+/** A distance from point `p` to line `lid` already in the drawing. */
+const pointLineDimOf = (sk: Sketch, p: string, lid: string): string | undefined => Object.keys(sk.cons).find(id => sk.cons[id].type === 'pldist' && sk.cons[id].p === p && sk.cons[id].l === lid);
+
 /**
  * Two things picked, at least one a wall's edge: the distance between them — two edges of one wall, its thickness
  * (`thickness` opens it); of two walls, face to face; an edge and a line, from that face; an edge and a point, from it.
@@ -417,7 +510,7 @@ export function dimPoints(a: string, b: string): void {
     title: 'Distance', ...startingValue(L), selectAll: true, laser: true,
     onDone: (v, capture) => {
       pushHistory();
-      const r = tryAddConstraint({ type: 'dist', a, b, kind: 'al', value: v, driving: true, off: 0, ...(capture !== undefined ? { capture } : {}) });
+      const r = tryAddConstraint({ ...pointsDim(a, b), value: v, ...(capture !== undefined ? { capture } : {}) });
       if (!r.ok) dropHistory();
       ed.sel = [];
       afterEdit();
@@ -432,8 +525,28 @@ export function dimPoints(a: string, b: string): void {
  * or, picked whole, each wall's room side (see faceToward).
  */
 export function dimTwoLines(l1: string, l2: string, sides: Record<string, 0 | 1 | -1> = {}): void {
-  const sk = SK(), L1 = sk.lines[l1], L2 = sk.lines[l2];
-  if (!L1 || !L2) return;
+  const sk = SK(), d = twoLinesDim(sk, l1, l2, sides);
+  if (!d) return;
+  if (d.existing) {
+    const c = sk.cons[d.existing];
+    // (the edges picked: it's measured between them now)
+    editDim(d.existing, undefined, false, c.type === 'pldist' && Object.keys(sides).length ? d.facesFrom(c.l!, c.p!) : undefined);
+    return;
+  }
+  if (d.c.type === 'angle') { dimAngle(l1, l2); return; }
+  const f = d.facesFrom(l1, d.c.p!);
+  dimPointLine(d.c.p!, l1, { keepParallel: l2, title: 'Distance between lines', faces: f.faces, l2: f.l2 });
+}
+
+/**
+ * What the + measures between two lines: their distance if they're parallel — square to the first, from the end of the
+ * second that sits most squarely across from it, between the faces `sides` says (see dimTwoLines) — otherwise the angle
+ * between them. `existing`: a dimension already between them; `facesFrom`: the faces between line `l` and the other,
+ * from point `p` on the other.
+ */
+function twoLinesDim(sk: Sketch, l1: string, l2: string, sides: Record<string, 0 | 1 | -1> = {}): { c: Constraint; existing?: string; facesFrom: (l: string, p: string) => FaceChoice } | null {
+  const L1 = sk.lines[l1], L2 = sk.lines[l2];
+  if (!L1 || !L2) return null;
   const [ax, ay] = norm2(sk.points[L1.b].x - sk.points[L1.a].x, sk.points[L1.b].y - sk.points[L1.a].y);
   const [bx, by] = norm2(sk.points[L2.b].x - sk.points[L2.a].x, sk.points[L2.b].y - sk.points[L2.a].y);
   const parallel = Math.abs(ax * by - ay * bx) < 0.02; // within about a degree
@@ -444,24 +557,16 @@ export function dimTwoLines(l1: string, l2: string, sides: Record<string, 0 | 1
     if (kind === 'angle') return (c.l1 === l1 && c.l2 === l2) || (c.l1 === l2 && c.l2 === l1);
     return (c.l === l1 && (c.p === L2.a || c.p === L2.b)) || (c.l === l2 && (c.p === L1.a || c.p === L1.b));
   });
-  /** The faces between line `l` (the one measured square to) and the other, from point `p` on the other. */
   const facesFrom = (l: string, p: string): FaceChoice => {
     const o = l === l1 ? l2 : l1, ol = sk.lines[o], on = sk.lines[l];
     return { faces: [faceToward(sk, l, sk.points[p], sides[l], true), faceToward(sk, o, sk.points[on.a], sides[o], true)], ...(faced(sk, o) && ol ? { l2: o } : {}) };
   };
-  if (existing) {
-    const c = sk.cons[existing];
-    // (the edges picked: it's measured between them now)
-    editDim(existing, undefined, false, c.type === 'pldist' && Object.keys(sides).length ? facesFrom(c.l!, c.p!) : undefined);
-    return;
-  }
-  if (!parallel) { dimAngle(l1, l2); return; }
-  // measure from the end of the second line that sits most squarely across from the first
+  if (!parallel) return { c: angleDim(l1, l2), existing, facesFrom };
   const A = sk.points[L1.a], B = sk.points[L1.b], len2 = (B.x - A.x) ** 2 + (B.y - A.y) ** 2 || 1;
   const t = (pid: string) => { const P = sk.points[pid]; return ((P.x - A.x) * (B.x - A.x) + (P.y - A.y) * (B.y - A.y)) / len2; };
   const p = Math.abs(t(L2.a) - 0.5) <= Math.abs(t(L2.b) - 0.5) ? L2.a : L2.b;
   const f = facesFrom(l1, p);
-  dimPointLine(p, l1, { keepParallel: l2, title: 'Distance between lines', faces: f.faces, l2: f.l2 });
+  return { c: pointLineDim(sk, p, l1, { faces: f.faces, l2: f.l2 }), existing, facesFrom };
 }
 
 /**
@@ -471,11 +576,7 @@ export function dimTwoLines(l1: string, l2: string, sides: Record<string, 0 | 1
  * switch them.
  */
 export function dimPointLine(p: string, lid: string, opts: { keepParallel?: string; title?: string; faces?: [number, number]; l2?: string } = {}): void {
-  const sk = SK(), l = sk.lines[lid], P = sk.points[p], A = sk.points[l.a], B = sk.points[l.b];
-  const sd = ((B.x - A.x) * (P.y - A.y) - (B.y - A.y) * (P.x - A.x)) / (hyp(B.x - A.x, B.y - A.y) || 1);
-  const sign = sd < 0 ? -1 : 1;
-  const c: Constraint = { type: 'pldist', p, l: lid, value: 0, sign, driving: true, ...(opts.l2 ? { l2: opts.l2 } : {}) };
-  applyFace(c, { faces: opts.faces ?? [faceToward(sk, lid, P), 0] });
+  const sk = SK(), c = pointLineDim(sk, p, lid, opts);
   const choices = faceChoices(sk, c);
   ed.sel = [];
   ed.preview = (cx, T) => { const e = dimEnds(sk, c); if (e) drawPendingDim(cx, T, { from: e.a, to: e.b, a: e.a, b: e.b, nx: 0, ny: 0, off: 0, label: pendingLabel(kpTyped(), measure(sk, c)) }); };
@@ -508,9 +609,10 @@ export function dimPointLine(p: string, lid: string, opts: { keepParallel?: stri
  */
 export function dimCurve(id: string, side?: 1 | -1): void {
   const sk = SK(), wall = !!wallOf(sk, id);
-  for (const k in sk.cons) { const c = sk.cons[k]; if (c.type === 'diam' && c.c === id) { editDim(k, undefined, false, wall && side ? { face: side } : undefined); return; } }
-  let face: 0 | 1 | -1 = wall ? side ?? defaultFace(sk, id, ed.wallTap?.id === id ? ed.wallTap.side : undefined) ?? 0 : 0;
-  const now = () => measure(sk, { type: 'diam', c: id, ...(face ? { face } : {}) });
+  const ex = diamDimOf(sk, id);
+  if (ex) { editDim(ex, undefined, false, wall && side ? { face: side } : undefined); return; }
+  let face: 0 | 1 | -1 = wall ? firstFace(sk, id, side) : 0;
+  const now = () => measure(sk, diamDim(id, face));
   // (while it's being entered, what it measures across is what's highlighted: the edge, or the wall)
   const was = ed.sel, type = sk.circles[id] ? 'circle' as const : 'arc' as const;
   const show = () => { ed.sel = face ? [{ type: 'wface', id: edgeId(id, face) }] : [{ type, id }]; requestDraw(); };
@@ -525,7 +627,7 @@ export function dimCurve(id: string, side?: 1 | -1): void {
     onDone: v => {
       if (v <= 0) return;
       pushHistory();
-      const r = tryAddConstraint({ type: 'diam', c: id, value: v, driving: true, ...(face ? { face } : {}) });
+      const r = tryAddConstraint({ ...diamDim(id, face), value: v });
       if (!r.ok) dropHistory();
       // (as a length: the dimension made, nothing left highlighted)
       ed.sel = [];
@@ -537,16 +639,23 @@ export function dimCurve(id: string, side?: 1 | -1): void {
 
 /** A corner's angle (two lines meeting at `pid`): its angle dimension's keypad, or a new one's. False if it isn't a corner. */
 export function cornerAngle(pid: string, done?: () => void, modeless = false): boolean {
-  const sk = SK(), pair = cornerLines(sk, pid);
-  if (!pair) return false;
+  const sk = SK(), d = cornerDim(sk, pid);
+  if (!d) return false;
   // edit the corner's existing angle dimension rather than stacking a second one
-  const ex = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'angle' && ((c.l1 === pair[0] && c.l2 === pair[1]) || (c.l1 === pair[1] && c.l2 === pair[0])); });
-  if (ex) editDim(ex, done, modeless); else dimAngle(pair[0], pair[1], done, modeless);
+  if (d.existing) editDim(d.existing, done, modeless); else dimAngle(d.c.l1!, d.c.l2!, done, modeless);
   return true;
 }
 
+/** A corner's angle (two lines meeting at `pid`), as the + measures it; `existing`, its angle dimension. Null if it isn't a corner. */
+function cornerDim(sk: Sketch, pid: string): { c: Constraint; existing?: string } | null {
+  const pair = cornerLines(sk, pid);
+  if (!pair) return null;
+  const existing = Object.keys(sk.cons).find(id => { const c = sk.cons[id]; return c.type === 'angle' && ((c.l1 === pair[0] && c.l2 === pair[1]) || (c.l1 === pair[1] && c.l2 === pair[0])); });
+  return { c: angleDim(pair[0], pair[1]), existing };
+}
+
 export function dimAngle(l1: string, l2: string, done?: () => void, modeless = false): void {
-  const c: Constraint = { type: 'angle', l1, l2, value: 0, driving: true };
+  const c = angleDim(l1, l2);
   const cur = measure(SK(), c);
   /** The angle dimension, driving, at `v` degrees (`extra`: what it's from). */
   const addAngle = (v: number, extra: Partial<Constraint>) => {

package/src/tools/line.ts

@@ -128,6 +128,10 @@ export function makeLineTool(): LineTool {
       splitWallsAtEnds(SK(), lid);
       if (settings.autoCons) {
         for (const g of s.guides || []) {
+          // level or plumb from the line's own start: the line itself is. Lined up with any other point ("Aligned"),
+          // only placed there — never tied to it (the user's call, 2026-11-05: a V between two unconnected points
+          // "just auto made" sat in space between them, and nothing said what it tied)
+          if ((g.kind === 'H' || g.kind === 'V') && g.from !== st.start) continue;
           if (g.kind === 'H') tryAddConstraint({ type: 'h', a: g.from, b: b.id }, { silent: true });
           else if (g.kind === 'V') tryAddConstraint({ type: 'v', a: g.from, b: b.id }, { silent: true });
           else if (g.kind === 'perp' && st.prev) tryAddConstraint({ type: 'perp', l1: st.prev, l2: lid }, { silent: true });