@reekon-tools/boldr-cad 1.4.0 → 1.6.0

package/src/model/trim.ts

@@ -0,0 +1,188 @@
+import { circleCircle, distSeg, hyp, lineCircleT, normAng, projT, segInter } from './geom';
+import { arcAngles } from './planGeom';
+import type { Sketch, XY } from './types';
+
+/*
+  Trim's geometry (the tool and the cutting: tools/modify.ts). An item — a line (a wall, a guide), an arc or a circle — is
+  cut wherever something crosses it, and wherever a point something else is attached at lies on it: another line's or
+  arc's end resting on it (a T, an arc drawn into a corner), a point held on it. A tap takes away the piece between the
+  cuts either side of it. Nothing here edits the sketch.
+*/
+
+export type TrimKind = 'line' | 'arc' | 'circle';
+export interface TrimItem { kind: TrimKind; id: string }
+
+/**
+ * A cut along an item: where (`at` — a line's 0..1 from A to B; an arc's angle round from its start, 0 to its sweep; a
+ * circle's angle, 0 to 2π; counter-clockwise) and what makes it: a point already there (`pt` — the trimmed end is that
+ * point, so what meets there stays joined), or a crossing (`line` / `curve` — a new point, held on what it crosses).
+ */
+export interface Cut { at: number; x: number; y: number; pt?: string; line?: string; curve?: string }
+
+/** The piece of an item between two cuts. Null: the item's own end — a circle has none, so either null is all of it. */
+export interface TrimPiece { item: TrimItem; lo: Cut | null; hi: Cut | null }
+
+/** A curve's circle, and the part of it that's there: from t0, counter-clockwise, `sweep` round (a circle's: all of it). */
+interface Round { o: XY; r: number; t0: number; sweep: number }
+
+function roundOf(sk: Sketch, it: TrimItem): Round | null {
+  if (it.kind === 'circle') {
+    const ci = sk.circles[it.id], o = ci && sk.points[ci.c];
+    return o ? { o, r: ci.r, t0: 0, sweep: 2 * Math.PI } : null;
+  }
+  const a = it.kind === 'arc' ? sk.arcs[it.id] : undefined;
+  if (!a || !sk.points[a.c] || !sk.points[a.a] || !sk.points[a.b]) return null;
+  const g = arcAngles(sk, a);
+  return { o: g.o, r: g.r, t0: g.t0, sweep: g.full ? 2 * Math.PI : normAng(g.t1 - g.t0) };
+}
+
+/** How far round from a round's start the direction to `p` is (radians, counter-clockwise). */
+const roundAt = (R: Round, p: XY): number => normAng(Math.atan2(p.y - R.o.y, p.x - R.o.x) - R.t0);
+
+/** How far `p` is from an item, as drawn (a wall: from its faces in); Infinity off its ends, or if it's gone. */
+export function distTo(sk: Sketch, it: TrimItem, p: XY): number {
+  if (it.kind === 'line') {
+    const l = sk.lines[it.id], A = l && sk.points[l.a], B = l && sk.points[l.b];
+    if (!A || !B) return Infinity;
+    return Math.max(0, distSeg(p, A, B) - (l.kind === 'wall' ? l.thick / 2 : 0));
+  }
+  const R = roundOf(sk, it), o = it.kind === 'circle' ? sk.circles[it.id] : sk.arcs[it.id];
+  if (!R || !o || (it.kind === 'arc' && roundAt(R, p) > R.sweep)) return Infinity;
+  return Math.max(0, Math.abs(hyp(p.x - R.o.x, p.y - R.o.y) - R.r) - (o.kind === 'wall' ? (o.thick || 4.5) / 2 : 0));
+}
+
+/** The point on an item (on its centreline, within its ends) nearest `p`: where on it a tap beside it is. */
+export function nearestOn(sk: Sketch, it: TrimItem, p: XY): XY {
+  if (it.kind === 'line') {
+    const l = sk.lines[it.id], A = sk.points[l.a], B = sk.points[l.b], t = Math.max(0, Math.min(1, projT(A, B, p)));
+    return { x: A.x + (B.x - A.x) * t, y: A.y + (B.y - A.y) * t };
+  }
+  const R = roundOf(sk, it);
+  if (!R) return p;
+  const d = hyp(p.x - R.o.x, p.y - R.o.y) || 1;
+  return { x: R.o.x + ((p.x - R.o.x) / d) * R.r, y: R.o.y + ((p.y - R.o.y) / d) * R.r };
+}
+
+/**
+ * The line, arc or circle nearest `p`, within `tol`: what a trim there is of. Not a wall face's own edges (the plan's)
+ * or a cabinet's: those are whole things, not pieces to cut away.
+ */
+export function trimItemAt(sk: Sketch, p: XY, tol: number): TrimItem | null {
+  const best = { it: null as TrimItem | null, d: tol };
+  const consider = (it: TrimItem) => { const d = distTo(sk, it, p); if (d <= best.d) { best.it = it; best.d = d; } };
+  for (const id in sk.lines) if (!sk.lines[id].anchor && !sk.lines[id].cab) consider({ kind: 'line', id });
+  for (const id in sk.arcs) consider({ kind: 'arc', id });
+  for (const id in sk.circles) consider({ kind: 'circle', id });
+  return best.it;
+}
+
+/**
+ * Every cut along an item, in order. `tol` (inches): a point this near it is on it; a cut this near its own end isn't
+ * one; cuts this near each other are one (a point there wins over a crossing).
+ */
+export function cutsOn(sk: Sketch, it: TrimItem, tol: number): Cut[] {
+  const pt = (id: string): XY | undefined => sk.points[id];
+  let A: XY | undefined, B: XY | undefined, len = 0, R: Round | null = null;
+  if (it.kind === 'line') {
+    const l = sk.lines[it.id];
+    A = l && pt(l.a); B = l && pt(l.b);
+    if (!A || !B) return [];
+    len = hyp(B.x - A.x, B.y - A.y);
+    if (len < 1e-9) return [];
+  } else {
+    R = roundOf(sk, it);
+    if (!R || R.r < 1e-9) return [];
+  }
+  const raw: Cut[] = [];
+  /** Where `p` is along the item, if it's inside it (clear of the item's own ends). */
+  const along = (p: XY): number | null => {
+    if (A && B) { const t = projT(A, B, p); return t * len > tol && (1 - t) * len > tol ? t : null; }
+    const s = roundAt(R!, p);
+    return it.kind === 'circle' || (s < R!.sweep && s * R!.r > tol && (R!.sweep - s) * R!.r > tol) ? s : null;
+  };
+  const add = (p: XY, by: Omit<Cut, 'at' | 'x' | 'y'>) => { const at = along(p); if (at != null) raw.push({ at, x: p.x, y: p.y, ...by }); };
+
+  // what crosses it: lines…
+  for (const id in sk.lines) {
+    if (it.kind === 'line' && id === it.id) continue;
+    const l = sk.lines[id], C = pt(l.a), D = pt(l.b);
+    if (!C || !D) continue;
+    if (A && B) { const r = segInter(A, B, C, D); if (r) add(r, { line: id }); }
+    else for (const t of lineCircleT(C, D, R!.o, R!.r)) add({ x: C.x + (D.x - C.x) * t, y: C.y + (D.y - C.y) * t }, { line: id });
+  }
+  // …and arcs and circles (an arc only where it's drawn)
+  const curves: TrimItem[] = [...Object.keys(sk.circles).map(id => ({ kind: 'circle' as const, id })), ...Object.keys(sk.arcs).map(id => ({ kind: 'arc' as const, id }))];
+  for (const cv of curves) {
+    if (cv.kind === it.kind && cv.id === it.id) continue;
+    const Q = roundOf(sk, cv);
+    if (!Q) continue;
+    const hits = A && B ? lineCircleT(A, B, Q.o, Q.r).map(t => ({ x: A!.x + (B!.x - A!.x) * t, y: A!.y + (B!.y - A!.y) * t })) : circleCircle(R!.o, R!.r, Q.o, Q.r);
+    for (const p of hits) if (cv.kind === 'circle' || roundAt(Q, p) <= Q.sweep + 1e-9) add(p, { curve: cv.id });
+  }
+  // the points on it that something else is attached at: other lines' and arcs' ends, points held on it
+  const held = new Set<string>();
+  for (const id in sk.lines) if (!(it.kind === 'line' && id === it.id)) { held.add(sk.lines[id].a); held.add(sk.lines[id].b); }
+  for (const id in sk.arcs) if (!(it.kind === 'arc' && id === it.id)) { held.add(sk.arcs[id].a); held.add(sk.arcs[id].b); }
+  for (const c of Object.values(sk.cons)) if (c.p && ((c.type === 'online' && !c.face && c.l === it.id) || (c.type === 'oncircle' && c.c === it.id))) held.add(c.p);
+  for (const id of held) {
+    const P = pt(id);
+    if (!P) continue;
+    const off = A && B ? distSeg(P, A, B) : Math.abs(hyp(P.x - R!.o.x, P.y - R!.o.y) - R!.r);
+    if (off <= tol) add(P, { pt: id });
+  }
+
+  raw.sort((a, b) => a.at - b.at);
+  const scale = A && B ? len : R!.r, out: Cut[] = [];
+  for (const c of raw) {
+    const last = out[out.length - 1];
+    if (last && (c.at - last.at) * scale <= tol) { if (c.pt && !last.pt) out[out.length - 1] = c; continue; }
+    out.push(c);
+  }
+  // (round a circle, the last cut and the first can be one place)
+  if (it.kind === 'circle' && out.length > 1 && (2 * Math.PI - out[out.length - 1].at + out[0].at) * scale <= tol) {
+    const last = out.pop()!;
+    if (last.pt && !out[0].pt) out[0] = last;
+  }
+  return out;
+}
+
+/** The piece of an item around `p` (on it): between the cuts either side of it. */
+export function pieceAt(sk: Sketch, it: TrimItem, p: XY, tol: number): TrimPiece {
+  const cuts = cutsOn(sk, it, tol);
+  let at: number;
+  if (it.kind === 'line') { const l = sk.lines[it.id]; at = projT(sk.points[l.a], sk.points[l.b], p); }
+  else { const R = roundOf(sk, it); at = R ? roundAt(R, p) : 0; }
+  if (it.kind === 'circle') {
+    // round a circle, the cut before it (from the last, if none is) and the one after (the first, if none is)
+    if (cuts.length < 2) return { item: it, lo: null, hi: null };
+    let lo = cuts[cuts.length - 1], hi = cuts[0];
+    for (const c of cuts) if (c.at <= at) lo = c;
+    for (const c of cuts) if (c.at > at) { hi = c; break; }
+    return { item: it, lo, hi };
+  }
+  let lo: Cut | null = null, hi: Cut | null = null;
+  for (const c of cuts) { if (c.at <= at) lo = c; else if (!hi) hi = c; }
+  return { item: it, lo, hi };
+}
+
+/** A piece as it's drawn: a segment, or a circle's arc from t0 counter-clockwise to t1 (radians). */
+export type PieceShape = { a: XY; b: XY } | { o: XY; r: number; t0: number; t1: number };
+
+export function pieceShape(sk: Sketch, pc: TrimPiece): PieceShape | null {
+  const it = pc.item;
+  if (it.kind === 'line') {
+    const l = sk.lines[it.id], A = l && sk.points[l.a], B = l && sk.points[l.b];
+    return A && B ? { a: pc.lo ?? A, b: pc.hi ?? B } : null;
+  }
+  const R = roundOf(sk, it);
+  if (!R) return null;
+  if (it.kind === 'circle') {
+    if (!pc.lo || !pc.hi) return { o: R.o, r: R.r, t0: 0, t1: 2 * Math.PI };
+    return { o: R.o, r: R.r, t0: pc.lo.at, t1: pc.hi.at > pc.lo.at ? pc.hi.at : pc.hi.at + 2 * Math.PI };
+  }
+  return { o: R.o, r: R.r, t0: R.t0 + (pc.lo?.at ?? 0), t1: R.t0 + (pc.hi?.at ?? R.sweep) };
+}
+
+/** One key per piece: a stroke takes each piece once, however many times it crosses it. */
+export const pieceKey = (pc: TrimPiece): string =>
+  pc.item.kind + ':' + pc.item.id + ':' + (pc.lo ? pc.lo.at.toFixed(9) : 's') + ':' + (pc.hi ? pc.hi.at.toFixed(9) : 'e');

package/src/model/types.ts

@@ -45,25 +45,29 @@ export interface Constraint {
   /**
    * dist, a wall's length: measured along this face of it — +1 the face to the left of its line's A → B, −1 the right
    * — corner to corner, as a tape measure along it reads. diam, a curved wall's: across its outer face (+1) or its
-   * inner face (−1). Unset, its centreline.
+   * inner face (−1). online, a point on a straight wall: on this face of it, half its thickness off the centreline.
+   * Unset, its centreline.
    */
   face?: 1 | -1;
   /**
    * pldist between two walls (`l`, and `l2`, the wall `p` is on): which face of each it's measured from — +1 the face
-   * toward the other, −1 the far one, 0 the centreline; unset, both centrelines.
+   * toward the other, −1 the far one, 0 the centreline; unset, both centrelines. eq: each line's length along this face
+   * of it, corner to corner, as `face` is for a wall's length (+1 the left of its A → B, −1 the right, 0 as drawn).
    */
   faces?: [number, number];
   value?: number;
   /** false = reference dimension (shown in parentheses, never drives geometry) */
   driving?: boolean;
-  /** label offset from the measured span (diameters: how far past the circle the label sits) */
+  /**
+   * label offset from the measured span, across it (a distance between parallel lines or walls: along them); a
+   * diameter's, how far past the circle the label sits; an angle's, its arc's radius once pulled off its corner
+   */
   off?: number;
-  /** diameters: direction of the diameter line, radians (default 60°) */
+  /** diameters: direction of the diameter line, radians (default 60°); an angle's label, from its corner (default: the bisector) */
   ang?: number;
   /** diameters: shown, entered and measured as a radius (a fillet's) — `value` is still the diameter */
   rad?: boolean;
   sign?: number;
-  layer?: 'print';
   /**
    * the drawing's own BOLDR measurement this driving dimension's value is kept in — made automatically by drawings
    * from before Save to group, and still kept in step for them; no new ones are made
@@ -88,7 +92,11 @@ export interface Constraint {
   anchor?: boolean;
 }
 
-/** A room: its corner points, and (for loops with curves) the line or arc id after each corner. */
+/**
+ * A room: its corner points, and (for loops with curves) the edge after each corner — a line's or an arc's id, or a
+ * circle's with the way round it ('<id>+' counter-clockwise, '<id>-' clockwise). Round a whole circle: no corners,
+ * loop [] and edges ['<id>+'] (model/rooms.ts).
+ */
 export interface Room { loop: string[]; name: string; edges?: string[] }
 /** An opening's two anchor points: its edges on the wall centerline (s0 nearer the line's start). */
 export type OpeningEdge = 's0' | 's1';
@@ -126,7 +134,10 @@ export interface Opening {
    */
   wSet?: boolean;
   type: 'door' | 'window';
+  /** a door: it swings to the right of its line's start → end (unset or false: to its left) */
   flip: boolean;
+  /** a door: the jamb it hangs on — its s1 edge (toward its line's end), or unset: its s0 edge. See flipDoor. */
+  hinge?: OpeningEdge;
   dims?: OpeningDim[];
   /** where the width dimension sits (as OpeningDim.off); unset = automatic */
   wOff?: number;
@@ -175,8 +186,9 @@ export interface LinkTarget {
 }
 
 /**
- * What a link is now, as the host says (LinkTarget has what it was when it was linked). A file's kind, for its icon:
- * 'photo', 'pdf', 'document', 'note', 'calculator', 'label', 'drawing' or anything else (a plain page).
+ * What a link is now, as the host says (LinkTarget has what it was when it was linked). A file's kind, for its tile
+ * (render/linkTile.ts tileTypeOf): 'photo', 'drawing' (a sketch: with its picture, a picture too), 'pdf', 'note',
+ * 'calculator' (a construction calculator), 'conversion', 'label', 'cad', or anything else (a document).
  */
 export interface LinkInfo {
   /** false once the host has looked and it's gone — never while it's still loading */
@@ -189,11 +201,18 @@ export interface LinkInfo {
   mkind?: string;
   /** µm for a length, degrees for an angle */
   value?: number;
-  /** the value as the host writes it */
+  /**
+   * What its tile shows as text, written the host's way: a measurement's value; a note's text — its blocks a blank line
+   * apart, a line within one for each of its lines, a list item's starting "• " and a numbered one's with its number
+   * ("1. "), each line wrapped to the tile, as many as fit (12 at most); a conversion's units, from and to, a line each,
+   * then the value typed as the conversion screen shows it (5' 3 1/2", 2 lbs 5 oz), if any
+   */
   text?: string;
   /** whether it can be opened from the drawing, and its measurement changed from it (unset: yes) */
   canOpen?: boolean;
   canEdit?: boolean;
+  /** whether it can be shown in a pane beside the drawing, when the host has one (CadLinks.openBeside; unset: yes) */
+  canOpenBeside?: boolean;
 }
 export interface Note {
   id: string;
@@ -277,6 +296,19 @@ export interface Sketch {
   faces?: Record<string, WallFace>;
   /** earlier versions' lines on wall elevations (same keys): moved into `faces` when the drawing loads */
   elev?: Record<string, ElevLine[]>;
+  /**
+   * A new page has no scale until its first length is entered (see model/scale.ts): what's drawn before it is a
+   * sketch, its inches only placeholders. Set on pages made since (newPage); a page without it has its scale.
+   */
+  unscaled?: boolean;
+  /** what the first length scaled the sketch by (its view zoomed by the inverse, so nothing moved): undone, it zooms back */
+  scaledBy?: number;
+  /**
+   * The size the page's tiles were first placed at, inches on the drawing: what the Tile size slider calls 100%. It
+   * scales with the page when the first length gives it its scale, as the tiles do, so the percent holds. Unset on a
+   * page from before it (its tiles' size now is 100%, kept once the slider's used).
+   */
+  tileRef?: number;
 }
 
 /** Photo or plan traced under the drawing. (x, y) is its top-left corner in world inches. */
@@ -294,6 +326,22 @@ export interface Underlay {
   rot?: number;
   /** locked images can't be moved, resized or turned (they still show, and can be unlocked) */
   locked?: boolean;
+  /**
+   * Cropped by its side handles (the user's call, 2026-11-03: they crop, never stretch): what's trimmed off each side of
+   * the picture, as a share of it (0 to 1 — l and r across it, t and b down it, as it's seen before it's turned). x, y,
+   * w, h are the part that shows; the picture is drawn whole past them and clipped, so a side dragged back out brings
+   * it back. Unset: all of it shows.
+   */
+  crop?: { l: number; t: number; r: number; b: number };
+  /**
+   * A photo of the job's, expanded from its tile (the user's call, 2026-10-26: "it expands the image to full size + shows
+   * a link icon in the corner", as Skia's annotation does): its picture is the one the host shows it as (LinkInfo.thumbUrl;
+   * `src` is left empty, so nothing of it is uploaded or kept with the drawing), the badge in its top-right corner opens
+   * it, and Expand in its bar folds it back into its tile. An image from the computer has none.
+   */
+  link?: LinkTarget;
+  /** an expanded photo's tile as it was (its look and its leader), to fold back into */
+  tile?: Omit<Note, 'x' | 'y' | 'link'>;
 }
 export interface View { cx: number; cy: number; s: number }
 /** underlays: the page's photos and plans, drawn in order (the last on top) */