@reekon-tools/boldr-cad 0.1.0 → 1.1.0

package/src/app/edit.ts

@@ -1,16 +1,22 @@
 import { drivingDim } from '../model/openings';
+import { edgeOf, wallOf } from '../model/planGeom';
 import { CONS_LABEL } from '../model/constraints';
 import { HS, stepRedo, stepUndo } from '../model/history';
+import { pushedOut, syncFaces } from '../model/facesolve';
+import { elevSyncFrame, fitState, overflow, pastWallMsg, restoreFit } from '../editor/elevation';
 import { resolveOpenings } from '../model/openings';
 import { gc, restorePos, snapshotPos } from '../model/sketch';
-import { page, saveSoon, SK } from '../model/store';
-import type { Constraint, SelItem } from '../model/types';
+import { page, planSK, saveSoon, SK } from '../model/store';
+import type { Constraint, SelItem, Sketch, WallFace } from '../model/types';
+import { cabOfPoint, cabPoints } from '../model/faces';
 import { requestDraw } from '../render/view';
 import { solver, type AddResult, type SolveResult } from '../solver';
 import { cancelTool } from '../tools/registry';
 import { fmtLen } from '../units';
 import { ed } from './state';
 import { refreshDrawerSoon, renderElevation, showConflict, toast, updateCtx, updateStatus } from '../editor/ports';
+import { refreshLinks } from '../editor/links';
+import { followLinked } from '../editor/linkFollow';
 
 export function analyze(): void {
   ed.ana = solver.analyzeDOF(SK());
@@ -25,9 +31,19 @@ export function solveOrRevert(): SolveResult {
   return s;
 }
 
+/**
+ * Walls made thicker or thinner, or lines turned into walls: what's measured on walls' faces holds, their centrelines
+ * moving to keep it (a face's length depends on the walls at its corners as well as its own). False — and nothing
+ * moved — when it can't hold.
+ */
+export function holdFaces(): boolean {
+  if (!Object.values(SK().cons).some(c => c.face || c.faces)) return true;
+  return solveOrRevert().ok;
+}
+
 /** Re-place locked doors/windows from their dimensions (after any geometry change). */
 export function resolveOpeningsNow(): void {
-  ed.badOpeningDims = resolveOpenings(SK());
+  ed.badOpeningDims = resolveOpenings(planSK());
 }
 
 export function existsSel(s: SelItem): boolean {
@@ -39,13 +55,17 @@ export function existsSel(s: SelItem): boolean {
     case 'arc': return !!sk.arcs[s.id];
     case 'cons': case 'dim': return !!sk.cons[s.id];
     case 'room': return !!sk.rooms[s.id];
-    case 'opening': return !!sk.openings[s.id];
+    case 'opening': return !!planSK().openings[s.id];
+    case 'cab': return !!(sk as WallFace).cabs?.[s.id];
+    case 'elev': return true;
+    case 'oanchor': return !!planSK().openings[s.id.split('|')[0]];
+    case 'wface': return !!wallOf(sk, edgeOf(s.id)[0]);
     case 'odim': {
-      const [op, part] = s.id.split('|'), o = sk.openings[op];
-      return !!o && (part.startsWith('d:') ? (o.dims || []).some(d => d.id === part.slice(2)) : !drivingDim(o));
+      const [op, part] = s.id.split('|'), o = planSK().openings[op];
+      return !!o && (part === 'w' || (part.startsWith('d:') ? (o.dims || []).some(d => d.id === part.slice(2)) : !drivingDim(o)));
     }
     case 'note': return sk.notes.some(n => n.id === s.id);
-    case 'underlay': return !!page().underlay;
+    case 'underlay': return page().underlays.some(u => u.id === s.id);
   }
   return false;
 }
@@ -53,8 +73,11 @@ export function existsSel(s: SelItem): boolean {
 /** Run after every model change: clean up, re-analyze, refresh UI, autosave. */
 export function afterEdit(): void {
   ed.editSeq++;
-  gc(SK());
+  gc(planSK()); // the plan, and each wall face
   resolveOpeningsNow();
+  // what's drawn on wall faces follows the plan's corners, doors and windows
+  ed.badFaceCons = syncFaces(planSK());
+  elevSyncFrame(); // the open wall's frame (its length, its corners) as the plan has it now
   ed.sel = ed.sel.filter(s => existsSel(s));
   analyze();
   updateCtx();
@@ -62,11 +85,13 @@ export function afterEdit(): void {
   refreshDrawerSoon();
   requestDraw();
   renderElevation();
+  refreshLinks(); // (what's linked may have changed: the host is asked about it)
+  followLinked(); // (and an undo may have put a linked dimension at something else than the job says)
   saveSoon();
 }
 
 export function undo(): void {
-  if (!HS().u.length) { toast('Nothing to undo'); return; }
+  if (!HS().u.length) { toast('Nothing to undo', { warn: true }); return; }
   cancelTool();
   stepUndo();
   ed.sel = [];
@@ -77,7 +102,7 @@ export function undo(): void {
 export function redo(): void {
   const h = HS();
   if (!h.u.length && !h.r.length) return;
-  if (!h.r.length) { toast('Nothing to redo'); return; }
+  if (!h.r.length) { toast('Nothing to redo', { warn: true }); return; }
   cancelTool();
   stepRedo();
   ed.sel = [];
@@ -85,19 +110,65 @@ export function redo(): void {
   toast('Redone');
 }
 
+/** Solve with these points held exactly where they are (fixed for the solve, then as they were). */
+function solveHolding(sk: Sketch, hold: string[]): SolveResult {
+  const pts = hold.map(id => sk.points[id]).filter(Boolean), had = pts.map(p => p.fixed);
+  pts.forEach(p => { p.fixed = true; });
+  const s = solver.solve(sk);
+  pts.forEach((p, i) => { if (had[i]) p.fixed = true; else delete p.fixed; });
+  return s;
+}
+
+/**
+ * The things a constraint ties together, each as the points to hold for it: a cabinet (its corners, when it's one of
+ * its edges or corners), a line (its ends), a point.
+ */
+export function holdGroups(sk: Sketch, c: Constraint): string[][] {
+  const face = sk as WallFace, groups: string[][] = [], seen = new Set<string>();
+  const add = (key: string, pts: string[]) => { if (!seen.has(key) && pts.length) { seen.add(key); groups.push(pts); } };
+  const point = (pid: string | undefined) => {
+    if (!pid || !sk.points[pid]) return;
+    const cab = cabOfPoint(sk, pid);
+    if (cab) add('cab:' + cab, cabPoints(face.cabs[cab])); else add('pt:' + pid, [pid]);
+  };
+  for (const lid of [c.l, c.l1, c.l2, c.line]) {
+    const l = lid ? sk.lines[lid] : undefined;
+    if (!l) continue;
+    if (l.cab && face.cabs?.[l.cab]) add('cab:' + l.cab, cabPoints(face.cabs[l.cab]));
+    else add('line:' + lid, [l.a, l.b]);
+  }
+  for (const pid of [c.a, c.b, c.p]) point(pid);
+  return groups;
+}
+
 /**
  * Add a constraint through the solver and explain the outcome:
  * reference dimension → toast, conflict → conflict sheet (unless silent).
  */
 export function tryAddConstraint(c: Constraint, { silent = false, onResolved = null as (() => void) | null } = {}): AddResult {
-  const r = solver.addConstraint(SK(), c, { explain: !silent });
+  // nothing may be pushed past its wall (in the wall view, past the wall; in the plan, a wall made shorter than
+  // what's on it): a constraint that would is taken back
+  const sk = SK(), was = overflow(sk), held = fitState(sk);
+  const r = solver.addConstraint(sk, c, { explain: !silent });
+  // met by moving everything a little, it ran past the wall: try keeping each thing it ties still in turn, so the
+  // other one moves to meet it (a short cabinet lifted to line up with a tall one, not the tall one sunk into the floor)
+  if (r.ok && r.id && !r.ref && pushedOut(was, overflow(sk))) {
+    for (const hold of holdGroups(sk, c)) {
+      restoreFit(sk, held);
+      if (solveHolding(sk, hold).ok && !pushedOut(was, overflow(sk))) return r;
+    }
+    delete sk.cons[r.id];
+    restoreFit(sk, held);
+    if (!silent) toast(pastWallMsg(), { warn: true });
+    return { ok: false };
+  }
   if (silent) return r;
   if (r.ref) {
     toast(r.refSame
       ? 'Added as a reference dimension. Other constraints already set this value.'
       : 'Kept as a reference dimension (' + fmtLen(c.value!) + '). Other constraints already set this value — remove one to drive it.', { warn: !r.refSame });
   } else if (r.redundant) {
-    toast(CONS_LABEL[c.type] + ' is already true — other constraints set it.');
+    toast(CONS_LABEL[c.type] + ' is already true — other constraints set it.', { warn: true });
   } else if (r.conflict === 'dependent') {
     showConflict({ title: 'Can’t add ' + (CONS_LABEL[c.type] || 'constraint').toLowerCase(), msg: 'It fights with constraints already on the drawing. Remove one of these to apply it.', ids: r.culprits || [], pending: c, onResolved });
   } else if (r.conflict === 'unsatisfiable') {

package/src/app/main.ts

@@ -2,10 +2,10 @@ import '../styles.css';
 import { initKeyboard } from '../input/keyboard';
 import { initPointer } from '../input/pointer';
 import { settings } from '../model/settings';
-import { load, page, saveNow, saveSoon, SK } from '../model/store';
+import { load, page, planSK, saveNow, saveSoon, SK } from '../model/store';
 import { hitAny } from '../render/hit';
 import { snapAt } from '../render/snap';
-import { cvs, fitView, initCanvas, mainT, resize, S, s2w } from '../render/view';
+import { cvs, fitView, initCanvas, mainT, noteHandles, resize, S, s2w } from '../render/view';
 import { registerTools, setTool, tools } from '../tools';
 import { initCtx, updateCtx } from '../ui/ctx';
 import { $ } from '../ui/dom';
@@ -27,7 +27,7 @@ import { applyTheme, initTheme } from '../ui/theme';
 import { initTopBar } from '../ui/topbar';
 import { initUnderlay } from '../ui/underlay';
 import { parseLen, fmtLen } from '../units';
-import { analyze, undo } from './edit';
+import { afterEdit, analyze, undo } from './edit';
 import { ed } from './state';
 import { resetSession } from '../model/session';
 
@@ -61,8 +61,10 @@ function init(): void {
   // test/debug hook (same shape as the prototype's)
   (window as unknown as { __boldr: unknown }).__boldr = {
     get sk() { return SK(); },
-    get underlay() { return page().underlay; },
-    analyze, tools, setTool, setMode,
+    get plan() { return planSK(); },
+    get underlay() { return page().underlays[0] ?? null; },
+    get images() { return page().underlays; },
+    analyze, afterEdit, tools, setTool, setMode,
     get sel() { return ed.sel; },
     set sel(v) { ed.sel = v; },
     fitView, parseLen, fmtLen,
@@ -70,7 +72,11 @@ function init(): void {
     get chips() { return ed.hitChips; },
     s2w, undo, snapAt, hitAny,
     w2s: (x: number, y: number) => S(mainT(), x, y),
+    /** a note's adjustment handles, on screen */
+    noteHandles: (id: string) => { const n = SK().notes.find(x => x.id === id); return n ? noteHandles(mainT(), n) : []; },
     get snap() { return ed.snapState; },
+    /** something is being drawn (a tool's preview) */
+    get previewing() { return !!ed.preview; },
     get elevHits() { return elevHits(); },
   };
 }

package/src/app/state.ts

@@ -1,4 +1,5 @@
 import { emptyAnalysis } from '../model/constraints';
+import { DEFAULT_NOTE_COLOR, DEFAULT_NOTE_WIDTH, NOTE_TEXT_IN, type NoteStyle } from '../model/markup';
 import type { Analysis, OpeningEdge, SelItem, SelType } from '../model/types';
 import type { Xform } from '../render/view';
 import { sessionState } from '../model/session';
@@ -8,14 +9,20 @@ export type Mode = 'draft' | 'annotate';
 
 /** Something under the pointer: geometry, or a chip/badge drawn on the canvas. */
 export interface Hit {
-  type: SelType | 'odim' | 'oanchor' | 'uhandle' | 'nhandle';
+  /** 'cabfoot': a cabinet's footprint in the plan (id: its wall face's key, '#', its id) */
+  type: SelType | 'odim' | 'oanchor' | 'uhandle' | 'nhandle' | 'cabfoot';
   id: string;
   /** a print dimension label */
   print?: boolean;
   /** low-priority hit (room fill) */
   weak?: boolean;
-  /** 'odim': 'w' width, 'a'/'b' distance to a wall end, or 'd:<id>' a placed dimension. 'oanchor': 's0'/'s1' edge. */
+  /**
+   * 'odim': 'w' width, 'a'/'b' distance to a wall end, or 'd:<id>' a placed dimension. 'oanchor': 's0'/'s1' edge.
+   * 'note', a link's tile: 'tip' its leader's tip, 'leader' along its leader (unset: its card).
+   */
   part?: string;
+  /** a wall picked whole: the side of its centreline the pointer was on (+1 the left of its A → B; a curved one's, outside) */
+  side?: 1 | -1;
 }
 
 export type OpeningDimPart = 'w' | 'a' | 'b' | `d:${string}`;
@@ -42,7 +49,8 @@ export interface Snap {
 
 /** Screen-space hit region registered while drawing chips, badges and labels. */
 export interface HitChip {
-  kind: 'dim' | 'pdim' | 'cons' | 'room' | 'odim';
+  /** 'elev': one of the wall view's dimension chips (id: what it measures, as JSON) */
+  kind: 'dim' | 'pdim' | 'cons' | 'room' | 'odim' | 'elev';
   part?: string;
   id: string;
   x: number; y: number; w: number; h: number;
@@ -68,20 +76,45 @@ export const ed = sessionState(() => ({
   ana: emptyAnalysis() as Analysis,
   lastPointerTouch: false,
   drawConstr: false,
+  /** the rail's Walls toggle: what's drawn (lines, rectangles, circles, arcs, Draw to shape) is walls */
+  drawWalls: false,
   dimLayer: 'drive' as 'drive' | 'print',
   openingType: 'door' as 'door' | 'window',
-  noteColor: '#F070EE',
+  /** new markup's look (the stroke panel sets them; selected markup changes with them) */
+  noteColor: DEFAULT_NOTE_COLOR,
+  noteWidth: DEFAULT_NOTE_WIDTH,
+  noteStyle: 'solid' as NoteStyle,
+  /** new text notes' letter height on the drawing, inches */
+  noteTextIn: NOTE_TEXT_IN,
   /** opening dimensions that can't be met (drawn red) */
   badOpeningDims: new Set<string>(),
+  /** wall-face constraints that can't be met (drawn red in the elevation) */
+  badFaceCons: new Set<string>(),
   /** dimension tool: an opening edge picked as the first end */
   /** body: the opening itself was tapped (not an edge square), so the edge is chosen from what it's measured to */
   pickedAnchor: null as { id: string; edge: OpeningEdge; body?: boolean } | null,
   /** bumped on every model change (so a double tap can't span an edit) */
   editSeq: 0,
+  /** the side a wall was last tapped on, picking it whole: between two spaces, its length is measured on that side */
+  wallTap: null as { id: string; side: 1 | -1 } | null,
   /** recently hovered points, used for alignment guides */
   recentPts: [] as string[],
   /** view only: pan and zoom, no tools, nothing saved (people who can't edit this job) */
   readOnly: false,
 }));
 
-export const isSel = (type: string, id: string): boolean => ed.sel.some(s => s.type === type && s.id === id);
+/**
+ * Whether something is selected. Drawing asks it of everything on the plan, every frame: with many things selected (a
+ * double tap takes in every wall joined to one) that was each against each, so a larger selection is looked up in a
+ * set, made again only when the selection changes (it's replaced, or added to).
+ */
+export function isSel(type: string, id: string): boolean {
+  const sel = ed.sel;
+  if (sel.length < 8) {
+    for (const s of sel) if (s.type === type && s.id === id) return true;
+    return false;
+  }
+  if (!selKeys || selKeys.sel !== sel || selKeys.n !== sel.length) selKeys = { sel, n: sel.length, keys: new Set(sel.map(s => s.type + ' ' + s.id)) };
+  return selKeys.keys.has(type + ' ' + id);
+}
+let selKeys: { sel: SelItem[]; n: number; keys: Set<string> } | null = null;

package/src/data/memory.ts

@@ -4,17 +4,20 @@ import type { CadDataProvider, CadFileMeta, CadMeasurementValue, CadPageDoc } fr
 
 const copy = <T,>(v: T): T => JSON.parse(JSON.stringify(v)) as T;
 
-export function memoryProvider(name = 'Test drawing', meta: CadFileMeta | null = null, pages: Record<string, CadPageDoc> = {}) {
-  const fileSubs = new Set<(f: { name: string; meta: CadFileMeta | null } | null) => void>();
-  const pageSubs = new Set<(p: Record<string, CadPageDoc>) => void>();
-  const state = { name, meta: meta && copy(meta), pages: copy(pages), writes: 0, uploads: 0, thumbnail: null as string | null, files: {} as Record<string, string>, measurements: {} as Record<string, CadMeasurementValue>, placed: [] as string[] };
+export function memoryProvider(name = 'Test drawing', meta: CadFileMeta | null = null, pages: Record<string, CadPageDoc> = {}, opts: { fromCache?: boolean } = {}) {
+  // (fromCache: what's here is the cache's word, as a device offline hears it, until confirm() brings the server's)
+  let fromCache = !!opts.fromCache;
+  const snap = () => ({ fromCache });
+  const fileSubs = new Set<(f: { name: string; meta: CadFileMeta | null } | null, m?: { fromCache: boolean }) => void>();
+  const pageSubs = new Set<(p: Record<string, CadPageDoc>, m?: { fromCache: boolean }) => void>();
+  const state = { name, meta: meta && copy(meta), pages: copy(pages), writes: 0, uploads: 0, thumbnail: null as string | null, files: {} as Record<string, string>, measurements: {} as Record<string, CadMeasurementValue>, placed: [] as string[], placedLinked: [] as { groupId: string; id: string; columnId?: string }[] };
   const measSubs = new Set<(v: Record<string, CadMeasurementValue>) => void>();
   const emitMeas = () => measSubs.forEach(cb => cb(copy(state.measurements)));
-  const emitFile = () => fileSubs.forEach(cb => cb({ name: state.name, meta: state.meta && copy(state.meta) }));
-  const emitPages = () => pageSubs.forEach(cb => cb(copy(state.pages)));
+  const emitFile = () => fileSubs.forEach(cb => cb({ name: state.name, meta: state.meta && copy(state.meta) }, snap()));
+  const emitPages = () => pageSubs.forEach(cb => cb(copy(state.pages), snap()));
   const provider: CadDataProvider = {
-    subscribeFile(cb) { fileSubs.add(cb); queueMicrotask(() => cb({ name: state.name, meta: state.meta && copy(state.meta) })); return () => { fileSubs.delete(cb); }; },
-    subscribePages(cb) { pageSubs.add(cb); queueMicrotask(() => cb(copy(state.pages))); return () => { pageSubs.delete(cb); }; },
+    subscribeFile(cb) { fileSubs.add(cb); queueMicrotask(() => cb({ name: state.name, meta: state.meta && copy(state.meta) }, snap())); return () => { fileSubs.delete(cb); }; },
+    subscribePages(cb) { pageSubs.add(cb); queueMicrotask(() => cb(copy(state.pages), snap())); return () => { pageSubs.delete(cb); }; },
     async writeMeta(m) { state.meta = copy(m); state.writes++; emitFile(); },
     async writePage(id, p) { state.pages[id] = copy(p); state.writes++; emitPages(); },
     async deletePage(id) { delete state.pages[id]; state.writes++; emitPages(); },
@@ -26,12 +29,14 @@ export function memoryProvider(name = 'Test drawing', meta: CadFileMeta | null =
       async create(m) { const id = 'm' + (Object.keys(state.measurements).length + 1); state.measurements[id] = copy(m); emitMeas(); return id; },
       async update(id, value) { state.measurements[id] = { ...state.measurements[id], value }; emitMeas(); },
       subscribe(cb) { measSubs.add(cb); queueMicrotask(() => cb(copy(state.measurements))); return () => { measSubs.delete(cb); }; },
-      async setPlaced(ids) { state.placed = ids.slice(); },
+      async setPlaced(ids, linked = []) { state.placed = ids.slice(); state.placedLinked = copy(linked); },
     },
   };
   /** Change a page as another device would. */
   const remote = (id: string, p: CadPageDoc) => { state.pages[id] = copy(p); emitPages(); };
   /** Change a measurement as someone else would (e.g. in the job's measurement list). */
   const remoteMeasurement = (id: string, value: number) => { state.measurements[id] = { ...state.measurements[id], value }; emitMeas(); };
-  return { provider, state, remote, remoteMeasurement };
+  /** The server's word after a start from the cache: everything is sent again, confirmed. */
+  const confirm = () => { fromCache = false; emitFile(); emitPages(); };
+  return { provider, state, remote, remoteMeasurement, confirm };
 }

package/src/data/provider.ts

@@ -19,20 +19,30 @@ export interface CadFileMeta {
   settings?: { wallH?: number; layers?: Partial<Layers> };
 }
 
-/** One page as stored. The underlay's src is an uploaded image's URL, never inline image data. */
+/** One page as stored. Its images' src are uploaded images' addresses, never inline image data. */
 export interface CadPageDoc {
   name: string;
   sk: Sketch;
-  underlay: Underlay | null;
+  /** the page's photos and plans, bottom first */
+  underlays: Underlay[];
+  /** pages written when a page held one image: read as `underlays` of that one, never written */
+  underlay?: Underlay | null;
   /** the editing session that wrote it last, and its write count (to recognise our own writes coming back) */
   rev?: { clientId: string; seq: number };
 }
 
+/**
+ * Where a snapshot came from: the local cache, which may be stale and, offline, empty for what was never read on this
+ * device, or the server. Unset: the server. Firestore delivers the cache's answer first when it's offline; subscribe
+ * with metadata changes included, so the server's confirmation of an empty collection still arrives.
+ */
+export interface CadSnapshotMeta { fromCache: boolean }
+
 export interface CadDataProvider {
-  /** The file's name and drawing record (null record: not a drawing yet). Returns an unsubscribe function. */
-  subscribeFile(cb: (file: { name: string; meta: CadFileMeta | null } | null) => void): () => void;
+  /** The file's name and drawing record (null record: not a drawing yet; null file: no such file). Returns an unsubscribe function. */
+  subscribeFile(cb: (file: { name: string; meta: CadFileMeta | null } | null, meta?: CadSnapshotMeta) => void): () => void;
   /** Every page of the drawing, by id. Returns an unsubscribe function. */
-  subscribePages(cb: (pages: Record<string, CadPageDoc>) => void): () => void;
+  subscribePages(cb: (pages: Record<string, CadPageDoc>, meta?: CadSnapshotMeta) => void): () => void;
   writeMeta(meta: CadFileMeta): Promise<void>;
   writePage(id: string, page: CadPageDoc): Promise<void>;
   deletePage(id: string): Promise<void>;
@@ -54,14 +64,19 @@ export interface CadDataProvider {
 export interface CadMeasurementValue { kind: 'length' | 'angle'; value: number }
 
 /**
- * The drawing's measurements in BOLDR. Every driving dimension set in the drawing is kept as one (scoped to the
- * drawing's file); changing one elsewhere changes the dimension.
+ * The drawing's own measurements in BOLDR (scoped to the drawing's file): the ones an earlier version kept for each
+ * driving dimension. They still follow their dimensions, and changing one elsewhere changes its dimension; no new ones
+ * are made (a dimension is saved to the group through CadEditorProps.links instead).
  */
 export interface CadMeasurements {
-  create(m: CadMeasurementValue): Promise<string>;
+  /** No longer called: kept so an older host still type-checks. */
+  create?(m: CadMeasurementValue): Promise<string>;
   update(id: string, value: number): Promise<void>;
   /** The drawing's measurements, by id. Returns an unsubscribe function. */
   subscribe(cb: (values: Record<string, CadMeasurementValue>) => void): () => void;
-  /** Record which measurements the drawing shows (for "Associated Files"). */
-  setPlaced?(ids: string[]): Promise<void>;
+  /**
+   * Record which measurements the drawing shows (for "Associated Files"): its own (`ids`, in the drawing's group), and
+   * the job's it's linked to (`linked`, each in its own group; a form's with its column). All of them, every time.
+   */
+  setPlaced?(ids: string[], linked?: { groupId: string; id: string; columnId?: string }[]): Promise<void>;
 }