@reekon-tools/boldr-cad 0.1.0 → 1.1.0

package/src/data/sync.ts

@@ -1,12 +1,18 @@
+import { imagesOf } from '../model/images';
 import { analyze } from '../app/edit';
 import { ed } from '../app/state';
 import { existsSel } from '../app/edit';
 import { refreshDrawerSoon, renderElevation, updateCtx, updateStatus, updateTopBar } from '../editor/ports';
+import { refreshLinks } from '../editor/links';
 import { newPage } from '../model/demo';
-import { clearPageHistory } from '../model/history';
+import { allCons } from '../model/faces';
+import { syncFaces } from '../model/facesolve';
+import { clearPageHistory, imageStored } from '../model/history';
 import { defaultLayers, settings } from '../model/settings';
-import { saveSoon, store, type Persistence } from '../model/store';
+import { store, type Persistence } from '../model/store';
 import type { Constraint, Page, Project } from '../model/types';
+import { dimMeasurement, dimValueOf } from '../model/measurement';
+import { linkedMeasurements } from '../model/links';
 import { setDimValue } from '../tools/dim';
 import { aliasImage, requestDraw } from '../render/view';
 import type { CadDataProvider, CadFileMeta, CadMeasurementValue, CadPageDoc } from './provider';
@@ -24,10 +30,16 @@ export class NotACadDrawing extends Error {
 }
 
 export interface CadSyncOptions {
-  /** start a new drawing when the file has no drawing record yet (a file just created for it) */
+  /**
+   * The file was just created here: start its first page without waiting for the server's word on its pages (offline,
+   * the cache says there are none, as it says of any drawing never opened on this device). Also starts a new drawing
+   * when the file has no drawing record yet.
+   */
   initialize?: boolean;
   /** a write or upload failed */
   onError?: (e: unknown) => void;
+  /** closes the drawing while it's still opening (the person left): the promise rejects and nothing is written */
+  signal?: AbortSignal;
 }
 
 export interface CadSync {
@@ -41,78 +53,77 @@ export interface CadSync {
   saveThumbnail(dataUrl: string): void;
   /** the URL to draw a stored underlay from (`stored:` references; see CadDataProvider.uploadImage) */
   imageUrl?(ref: string): Promise<string>;
+  /** whether the drawing open in the editor differs from what was last saved (or taken in) */
+  hasChanges(): boolean;
+  /** how many writes or uploads have failed so far (a save failed if this grew) */
+  failures(): number;
 }
 
-const LENGTHS = new Set<Constraint['type']>(['dist', 'pldist', 'diam']);
-
 /**
- * A driving dimension's value as BOLDR keeps it: lengths in micrometres, angles in degrees. Null for what isn't a
- * measurement: reference and print dimensions, and constraints without a value.
+ * A driving dimension's value as BOLDR keeps it: lengths in micrometres, angles in degrees. Null for what isn't one of
+ * the drawing's own measurements: reference and print dimensions, constraints without a value, and dimensions linked
+ * to a measurement of the job (the job's, not the drawing's: see editor/links.ts).
  */
 export function measurementOf(c: Constraint): CadMeasurementValue | null {
-  if (c.driving === false || c.layer === 'print' || c.value == null) return null;
-  if (c.type === 'angle') return { kind: 'angle', value: Math.round(c.value * 100) / 100 };
-  if (LENGTHS.has(c.type)) return { kind: 'length', value: Math.round(c.value * 25400) };
-  return null;
+  return c.measurementRef ? null : dimMeasurement(c);
 }
-const toInches = (m: CadMeasurementValue): number => (m.kind === 'angle' ? m.value : m.value / 25400);
 
 /** The id of a new drawing's first page. */
 export const FIRST_PAGE_ID = 'page-1';
 
-const pageJson = (p: { name: string; sk: unknown; underlay: unknown }) => JSON.stringify({ name: p.name, sk: p.sk, underlay: p.underlay });
+const pageJson = (p: { name: string; sk: unknown; underlays?: unknown; underlay?: unknown }) =>
+  JSON.stringify({ name: p.name, sk: p.sk, underlays: imagesOf(p as Parameters<typeof imagesOf>[0]) });
 const newClientId = () => Date.now().toString(36) + '-' + Math.floor(Math.random() * 0x100000000).toString(36);
 
 export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions = {}): Promise<CadSync> {
   const clientId = newClientId();
   let seq = 0, file: { name: string; meta: CadFileMeta | null } | null | undefined, pages: Record<string, CadPageDoc> | undefined;
+  /** whether the latest file and pages snapshots are the cache's word rather than the server's */
+  let fileFromCache = false, pagesFromCache = false;
   /** what each page looked like when last saved or taken in (to tell local edits from remote ones) */
   const saved = new Map<string, string>();
+  /** removed pages whose delete is queued or in flight */
+  const deleting = new Set<string>();
   /** pages with a write queued or in flight (count per page) */
   const writing = new Map<string, number>();
   let savedMeta = '', project: Project | null = null, chain: Promise<void> = Promise.resolve(), stopped = false;
-  const fail = (e: unknown) => { opts.onError?.(e); };
+  let failures = 0;
+  const fail = (e: unknown) => { failures++; opts.onError?.(e); };
   const meas = provider.measurements;
   /** each measurement's value as last written or seen (undefined: not heard from BOLDR yet) */
   const known = new Map<string, number>();
-  /** dimensions whose measurement is being created: "pageId|constraintId" */
-  const creating = new Set<string>();
   /** each dimension's measurement, so a dimension that undo brought back without its id gets the same one again */
   const linked = new Map<string, string>();
   let placed = '', unsubMeas: (() => void) | null = null;
   const pagesNow = () => (store.project === project ? store.project : project)?.pages ?? [];
 
-  /** Every driving dimension is kept as a BOLDR measurement: create the missing ones, update the changed ones. */
+  /**
+   * The drawing's own measurements in BOLDR follow its dimensions: one a dimension already has (made by an earlier
+   * version, which kept every driving dimension as one) gets its new value. A new dimension stays the drawing's alone
+   * until the person saves it to the group (editor/linkActions.ts), when it's linked like any other measurement of the
+   * job — and those are the job's to keep (the host's `links`), never written here.
+   */
   function linkMeasurements(p: Project): void {
     if (!meas) return;
     const ids = new Set<string>();
-    for (const pg of p.pages) for (const [cid, c] of Object.entries(pg.sk.cons)) {
+    for (const pg of p.pages) for (const [cid, c] of allCons(pg.sk)) {
       const key = pg.id + '|' + cid;
+      // (linked to the job's: not the drawing's own, whatever it was before)
+      if (c.measurementRef) { if (c.measurementId) delete c.measurementId; linked.delete(key); continue; }
       if (!c.measurementId && linked.has(key)) c.measurementId = linked.get(key);
-      if (c.measurementId) { ids.add(c.measurementId); linked.set(key, c.measurementId); }
+      if (!c.measurementId) continue;
+      ids.add(c.measurementId);
+      linked.set(key, c.measurementId);
       const m = measurementOf(c);
-      if (!m) continue;
-      if (!c.measurementId) {
-        if (creating.has(key)) continue;
-        creating.add(key);
-        queue(async () => {
-          try {
-            const id = await meas.create(m);
-            known.set(id, m.value);
-            linked.set(key, id);
-            // the page's sketch may have been replaced since (undo): stamp the dimension as it is now
-            const cur = pagesNow().find(x => x.id === pg.id)?.sk.cons[cid];
-            if (cur && !cur.measurementId) { cur.measurementId = id; saveSoon(); }
-          } finally { creating.delete(key); }
-        });
-      } else if (known.has(c.measurementId) && known.get(c.measurementId) !== m.value) {
+      if (m && known.has(c.measurementId) && known.get(c.measurementId) !== m.value) {
         const id = c.measurementId;
         known.set(id, m.value);
         queue(() => meas.update(id, m.value));
       }
     }
-    const pj = JSON.stringify([...ids].sort());
-    if (meas.setPlaced && pj !== placed) { placed = pj; queue(() => meas.setPlaced!(JSON.parse(pj) as string[])); }
+    // where the drawing shows measurements: its own, and the job's it's linked to (each with its own group)
+    const job = linkedMeasurements(p), pj = JSON.stringify([[...ids].sort(), job.map(j => j.groupId + '|' + j.id + '|' + (j.columnId ?? '')).sort()]);
+    if (meas.setPlaced && pj !== placed) { placed = pj; const own = [...ids].sort(); queue(() => meas.setPlaced!(own, job)); }
   }
 
   /** A measurement changed elsewhere (or while the drawing was closed): its dimension follows. */
@@ -121,13 +132,21 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
       const prev = known.get(id);
       known.set(id, mv.value);
       if (prev === mv.value) continue;
-      for (const pg of pagesNow()) for (const [cid, c] of Object.entries(pg.sk.cons)) {
+      for (const pg of pagesNow()) for (const [cid, c] of allCons(pg.sk)) {
         if (c.measurementId !== id) continue;
         const m = measurementOf(c);
         if (!m || m.value === mv.value) continue;
+        const editing = store.project === project && pg.id === store.curPageId;
+        const v = dimValueOf(c, mv); // (a fillet's radius is kept as its diameter)
+        if (!pg.sk.cons[cid]) {
+          // on a wall face: the face solves now on the page being edited (positions stay if it can't), elsewhere when next edited
+          c.value = v;
+          if (editing) { ed.badFaceCons = syncFaces(pg.sk); analyze(); requestDraw(); renderElevation(); }
+          continue;
+        }
         // on the page being edited the drawing solves now (or explains why it can't); elsewhere when next edited
-        if (store.project === project && pg.id === store.curPageId) setDimValue(cid, toInches(mv));
-        else c.value = toInches(mv);
+        if (editing) setDimValue(cid, v);
+        else c.value = v;
       }
     }
   }
@@ -137,7 +156,7 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
     format: 'boldr-cad', version: 1, pageOrder: p.pages.map(pg => pg.id),
     settings: { wallH: settings.wallH, layers: { ...settings.layers } },
   });
-  const docOf = (pg: Page): CadPageDoc => ({ name: pg.name, sk: pg.sk, underlay: pg.underlay, rev: { clientId, seq: ++seq } });
+  const docOf = (pg: Page): CadPageDoc => ({ name: pg.name, sk: pg.sk, underlays: pg.underlays, rev: { clientId, seq: ++seq } });
 
   /** Take in pages and the record someone else changed, where nothing local is unsaved. */
   function takeIn(): void {
@@ -149,10 +168,11 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
       const json = pageJson(doc), local = project.pages.find(p => p.id === id);
       if (local) {
         if (pageJson(local) !== saved.get(id) || json === saved.get(id)) continue; // edited here since, or nothing new
-        local.name = doc.name; local.sk = doc.sk; local.underlay = doc.underlay;
+        local.name = doc.name; local.sk = doc.sk; local.underlays = imagesOf(doc);
         clearPageHistory(id);
         if (id === store.curPageId) curChanged = true;
-      } else project.pages.push({ id, name: doc.name, sk: doc.sk, underlay: doc.underlay, view: null });
+      } else if (saved.has(id)) continue; // removed here (not saved yet, or its delete is on the way)
+      else project.pages.push({ id, name: doc.name, sk: doc.sk, underlays: imagesOf(doc), view: null });
       saved.set(id, json);
       changed = true;
     }
@@ -165,7 +185,7 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
     if (file && file.name !== project.name) { project.name = file.name; changed = true; }
     if (!changed) return;
     if (curChanged) { analyze(); ed.sel = ed.sel.filter(existsSel); }
-    updateTopBar(); updateCtx(); updateStatus(); refreshDrawerSoon(); renderElevation(); requestDraw();
+    updateTopBar(); updateCtx(); updateStatus(); refreshDrawerSoon(); renderElevation(); requestDraw(); refreshLinks();
   }
 
   const persistence: Persistence = {
@@ -176,6 +196,8 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
       const st = file?.meta?.settings;
       if (st?.wallH) settings.wallH = st.wallH;
       if (st?.layers) settings.layers = Object.assign(defaultLayers(), st.layers);
+      // the record as this editor would write it (a record missing newer settings isn't an unsaved change)
+      if (file?.meta) savedMeta = JSON.stringify(metaOf(project));
     },
     save() {
       const p = store.project;
@@ -190,24 +212,39 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
         queue(async () => {
           try {
             // traced images are stored as files: upload, then keep the reference (the picture already shown stays)
-            if (pg.underlay && pg.underlay.src.startsWith('data:')) {
-              const local = pg.underlay.src, ref = await provider.uploadImage(pg.id, local);
+            for (const u of pg.underlays) {
+              if (!u.src.startsWith('data:')) continue;
+              const local = u.src, ref = await provider.uploadImage(pg.id, local);
               aliasImage(local, ref);
-              pg.underlay.src = ref;
+              // the same picture wherever it's held: the page (if it's still there), and its undo steps
+              for (const v of pg.underlays) if (v.src === local) v.src = ref;
+              imageStored(pg.id, local, ref);
               saved.set(pg.id, pageJson(pg));
               requestDraw();
             }
             await provider.writePage(pg.id, docOf(pg));
+          } catch (e) {
+            // not written: the page counts as changed again, so the next save retries it
+            if (saved.get(pg.id) === json || saved.get(pg.id) === pageJson(pg)) saved.delete(pg.id);
+            throw e;
           } finally { done(); }
         });
       }
       for (const id of [...saved.keys()]) {
-        if (p.pages.some(pg => pg.id === id)) continue;
-        saved.delete(id);
-        queue(() => provider.deletePage(id));
+        if (p.pages.some(pg => pg.id === id) || deleting.has(id)) continue;
+        deleting.add(id);
+        queue(async () => {
+          try { await provider.deletePage(id); saved.delete(id); } finally { deleting.delete(id); }
+        });
       }
       const meta = metaOf(p), mj = JSON.stringify(meta);
-      if (mj !== savedMeta) { savedMeta = mj; queue(() => provider.writeMeta(meta)); }
+      if (mj !== savedMeta) {
+        const was = savedMeta;
+        savedMeta = mj;
+        queue(async () => {
+          try { await provider.writeMeta(meta); } catch (e) { if (savedMeta === mj) savedMeta = was; throw e; }
+        });
+      }
       return true;
     },
   };
@@ -216,12 +253,17 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
     let ready = false;
     const tryOpen = () => {
       if (ready || file === undefined || pages === undefined) return;
+      // the cache's word isn't final: a file it hasn't got, or a drawing whose pages it hasn't got, may well be on the
+      // server — wait for its answer (a file just created here is fresh: its first page is made without waiting)
+      if (file === null && fileFromCache) return;
+      const fresh = !!opts.initialize && !file?.meta?.pageOrder.length;
+      if (file && !Object.keys(pages).length && pagesFromCache && !fresh) return;
       ready = true;
       if (file === null) { stop(); reject(new NotACadDrawing('missing')); return; }
       if (!file.meta && !opts.initialize) { stop(); reject(new NotACadDrawing('legacy')); return; }
       const order = file.meta?.pageOrder ?? [];
       const ids = [...order.filter(id => pages![id]), ...Object.keys(pages!).filter(id => !order.includes(id))];
-      project = { name: file.name, pages: ids.map(id => ({ id, name: pages![id].name, sk: pages![id].sk, underlay: pages![id].underlay, view: null })) };
+      project = { name: file.name, pages: ids.map(id => ({ id, name: pages![id].name, sk: pages![id].sk, underlays: imagesOf(pages![id]), view: null })) };
       for (const id of ids) saved.set(id, pageJson(pages![id]));
       if (file.meta) savedMeta = JSON.stringify(file.meta);
       // a new drawing (or one whose pages are all gone) starts with one empty page, saved straight away; its id is
@@ -238,11 +280,23 @@ export function openCadDrawing(provider: CadDataProvider, opts: CadSyncOptions =
         persistence, stop, idle: () => chain,
         saveThumbnail: dataUrl => { if (provider.uploadThumbnail) queue(() => provider.uploadThumbnail!(dataUrl)); },
         imageUrl: provider.imageUrl ? ref => provider.imageUrl!(ref) : undefined,
+        hasChanges: () => {
+          const p = store.project === project ? store.project : project;
+          if (!p) return false;
+          if (p.pages.some(pg => pageJson(pg) !== saved.get(pg.id))) return true;
+          if ([...saved.keys()].some(id => !p.pages.some(pg => pg.id === id))) return true;
+          return JSON.stringify(metaOf(p)) !== savedMeta;
+        },
+        failures: () => failures,
       });
     };
-    const unsubFile = provider.subscribeFile(f => { file = f; if (ready) takeIn(); else tryOpen(); });
-    const unsubPages = provider.subscribePages(p => { pages = p; if (ready) takeIn(); else tryOpen(); });
+    const unsubFile = provider.subscribeFile((f, m) => { file = f; fileFromCache = !!m?.fromCache; if (ready) takeIn(); else tryOpen(); });
+    const unsubPages = provider.subscribePages((p, m) => { pages = p; pagesFromCache = !!m?.fromCache; if (ready) takeIn(); else tryOpen(); });
     unsubMeas = meas ? meas.subscribe(takeInMeasurements) : null;
     function stop() { stopped = true; unsubFile(); unsubPages(); unsubMeas?.(); }
+    // left while still opening: let go of the drawing, nothing written
+    const abort = () => { if (ready) return; ready = true; stop(); reject(new Error('closed')); };
+    if (opts.signal?.aborted) abort();
+    else opts.signal?.addEventListener('abort', abort, { once: true });
   });
 }