@fieldnotes/core 0.52.0 → 0.52.2

package/dist/index.cjs

@@ -983,6 +983,12 @@ function getElementBounds(element) {
   }
   return null;
 }
+function getElementVisualBounds(element) {
+  const bounds = getElementBounds(element);
+  if (!bounds) return null;
+  const rotation = element.rotation ?? 0;
+  return rotation === 0 ? bounds : rotatedAABB(bounds, rotation);
+}
 function getArrowBoundsAnalytical(from, to, bend) {
   if (bend === 0) {
     const minX2 = Math.min(from.x, to.x);
@@ -2754,10 +2760,7 @@ var ElementStore = class {
   // Spatial index stores the rotation-expanded AABB so rotated elements remain
   // broad-phase hit-test/marquee candidates; precise tests run against local bounds.
   indexBounds(element) {
-    const bounds = getElementBounds(element);
-    if (!bounds) return null;
-    const angle = element.rotation ?? 0;
-    return angle === 0 ? bounds : rotatedAABB(bounds, angle);
+    return getElementVisualBounds(element);
   }
   add(element, meta) {
     element = sanitizeRichText(element);
@@ -4921,6 +4924,57 @@ function createDomLayer() {
   });
   return el;
 }
+function createPaintStack() {
+  const el = createDomLayer();
+  el.dataset["fieldnotesPaintStack"] = "";
+  el.style.transformOrigin = "";
+  return el;
+}
+
+// src/canvas/hybrid-render-surface.ts
+var HybridRenderSurface = class {
+  constructor(root) {
+    this.root = root;
+  }
+  canvases = /* @__PURE__ */ new Map();
+  beginFrame(activeOrders, width, height) {
+    for (const [order, canvas] of this.canvases) {
+      if (!activeOrders.has(order)) {
+        canvas.remove();
+        this.canvases.delete(order);
+      }
+    }
+    for (const order of activeOrders) {
+      const canvas = this.getCanvas(order);
+      if (canvas.width !== width) canvas.width = width;
+      if (canvas.height !== height) canvas.height = height;
+      canvas.style.zIndex = String(order);
+    }
+  }
+  getContext(order) {
+    return this.getCanvas(order).getContext("2d");
+  }
+  clear() {
+    for (const canvas of this.canvases.values()) canvas.remove();
+    this.canvases.clear();
+  }
+  getCanvas(order) {
+    let canvas = this.canvases.get(order);
+    if (canvas) return canvas;
+    canvas = document.createElement("canvas");
+    canvas.dataset["paintOrder"] = String(order);
+    Object.assign(canvas.style, {
+      position: "absolute",
+      inset: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none"
+    });
+    this.root.appendChild(canvas);
+    this.canvases.set(order, canvas);
+    return canvas;
+  }
+};
 
 // src/elements/arrow-label-editor.ts
 var ArrowLabelEditor = class {
@@ -6539,6 +6593,7 @@ var DoubleTapDetector = class {
 // src/canvas/dom-node-manager.ts
 var DomNodeManager = class {
   domNodes = /* @__PURE__ */ new Map();
+  strata = /* @__PURE__ */ new Map();
   htmlContent = /* @__PURE__ */ new Map();
   domLayer;
   onEditRequest;
@@ -6547,6 +6602,7 @@ var DomNodeManager = class {
   lastSyncedVersion = /* @__PURE__ */ new Map();
   lastSyncedZIndex = /* @__PURE__ */ new Map();
   lastSyncedOpacity = /* @__PURE__ */ new Map();
+  cameraTransform = "";
   constructor(deps) {
     this.domLayer = deps.domLayer;
     this.onEditRequest = deps.onEditRequest;
@@ -6556,6 +6612,11 @@ var DomNodeManager = class {
   getNode(id) {
     return this.domNodes.get(id);
   }
+  setCameraTransform(transform) {
+    if (transform === this.cameraTransform) return;
+    this.cameraTransform = transform;
+    for (const stratum of this.strata.values()) stratum.style.transform = transform;
+  }
   storeHtmlContent(elementId, dom) {
     this.htmlContent.set(elementId, dom);
   }
@@ -6583,7 +6644,7 @@ var DomNodeManager = class {
         position: "absolute",
         pointerEvents: "auto"
       });
-      this.domLayer.appendChild(node);
+      this.getStratum(zIndex).appendChild(node);
       this.domNodes.set(element.id, node);
     } else if (this.getVersion) {
       const currentVersion = this.getVersion(element.id);
@@ -6594,6 +6655,15 @@ var DomNodeManager = class {
         return;
       }
     }
+    if (node.parentElement !== this.getStratum(zIndex)) {
+      const previousStratum = node.parentElement;
+      this.getStratum(zIndex).appendChild(node);
+      if (previousStratum?.childElementCount === 0) {
+        const previousOrder = Number(previousStratum.dataset["paintOrder"]);
+        previousStratum.remove();
+        this.strata.delete(previousOrder);
+      }
+    }
     if (this.getVersion) {
       this.lastSyncedVersion.set(element.id, this.getVersion(element.id));
       this.lastSyncedZIndex.set(element.id, zIndex);
@@ -6615,7 +6685,10 @@ var DomNodeManager = class {
   }
   hideDomNode(id) {
     const node = this.domNodes.get(id);
-    if (node) node.style.display = "none";
+    if (node) {
+      node.style.display = "none";
+      this.lastSyncedVersion.delete(id);
+    }
   }
   removeDomNode(id) {
     this.htmlContent.delete(id);
@@ -6624,8 +6697,14 @@ var DomNodeManager = class {
     this.lastSyncedOpacity.delete(id);
     const node = this.domNodes.get(id);
     if (node) {
+      const stratum = node.parentElement;
       node.remove();
       this.domNodes.delete(id);
+      if (stratum?.childElementCount === 0) {
+        const order = Number(stratum.dataset["paintOrder"]);
+        stratum.remove();
+        this.strata.delete(order);
+      }
     }
   }
   clearDomNodes() {
@@ -6635,6 +6714,27 @@ var DomNodeManager = class {
     this.lastSyncedVersion.clear();
     this.lastSyncedZIndex.clear();
     this.lastSyncedOpacity.clear();
+    for (const stratum of this.strata.values()) stratum.remove();
+    this.strata.clear();
+  }
+  getStratum(order) {
+    let stratum = this.strata.get(order);
+    if (stratum) return stratum;
+    stratum = document.createElement("div");
+    stratum.dataset["paintOrder"] = String(order);
+    Object.assign(stratum.style, {
+      position: "absolute",
+      inset: "0",
+      width: "100%",
+      height: "100%",
+      pointerEvents: "none",
+      transformOrigin: "0 0",
+      transform: this.cameraTransform,
+      zIndex: String(order)
+    });
+    this.domLayer.appendChild(stratum);
+    this.strata.set(order, stratum);
+    return stratum;
   }
   reattachHtmlContent(store) {
     for (const el of store.getElementsByType("html")) {
@@ -6816,6 +6916,7 @@ var RenderLoop = class {
   domNodeManager;
   layerCache;
   marginViewport;
+  hybridSurface;
   activeDrawingLayerId = null;
   gridCacheDirty = true;
   // set on recenter/viewport-change; consumed by the grid block
@@ -6835,6 +6936,7 @@ var RenderLoop = class {
     this.domNodeManager = deps.domNodeManager;
     this.layerCache = deps.layerCache;
     this.marginViewport = deps.marginViewport;
+    this.hybridSurface = deps.hybridSurface;
   }
   requestRender() {
     this.needsRender = true;
@@ -6955,9 +7057,19 @@ var RenderLoop = class {
       h: cullBounds.h + cullPad * 2
     };
     const allElements = this.store.getAll();
+    const visibleElements = allElements.filter(
+      (element) => this.layerManager.isLayerVisible(element.layerId)
+    );
+    const firstDomIndex = visibleElements.findIndex(
+      (element) => this.renderer.isDomElement(element)
+    );
+    const hybridActive = firstDomIndex >= 0 && visibleElements.slice(firstDomIndex + 1).some((element) => !this.renderer.isDomElement(element));
+    const hybridCanvasRuns = /* @__PURE__ */ new Map();
+    const hybridOrders = /* @__PURE__ */ new Set();
+    let activeHybridOrder = null;
     this.layerGroups.clear();
     const gridElements = [];
-    let domZIndex = 0;
+    let paintOrder = 0;
     for (const element of allElements) {
       if (!this.layerManager.isLayerVisible(element.layerId)) {
         if (this.renderer.isDomElement(element)) {
@@ -6965,14 +7077,27 @@ var RenderLoop = class {
         }
         continue;
       }
+      const order = ++paintOrder;
       if (this.renderer.isDomElement(element)) {
+        activeHybridOrder = null;
         const layerOpacity = this.layerManager.getLayer?.(element.layerId)?.opacity ?? 1;
-        const elBounds = getElementBounds(element);
+        const elBounds = getElementVisualBounds(element);
         if (elBounds && !boundsIntersect(elBounds, cullingRect)) {
           this.domNodeManager.hideDomNode(element.id);
         } else {
-          this.domNodeManager.syncDomNode(element, domZIndex++, layerOpacity);
+          this.domNodeManager.syncDomNode(element, order, layerOpacity);
+        }
+        continue;
+      }
+      if (hybridActive && paintOrder > firstDomIndex + 1 && element.type !== "grid") {
+        activeHybridOrder ??= order;
+        let run = hybridCanvasRuns.get(activeHybridOrder);
+        if (!run) {
+          run = [];
+          hybridCanvasRuns.set(activeHybridOrder, run);
+          hybridOrders.add(activeHybridOrder);
         }
+        run.push(element);
         continue;
       }
       if (element.type === "grid") {
@@ -6986,6 +7111,10 @@ var RenderLoop = class {
       }
       group.push(element);
     }
+    const activeTool = this.toolManager.activeTool;
+    const overlayOrder = visibleElements.length + 1;
+    if (hybridActive && activeTool?.renderOverlay) hybridOrders.add(overlayOrder);
+    this.hybridSurface.beginFrame(hybridOrders, this.canvasEl.width, this.canvasEl.height);
     for (const [layerId, elements] of this.layerGroups) {
       const isActiveDrawingLayer = layerId === this.activeDrawingLayerId;
       const layerOpacity = this.layerManager.getLayer?.(layerId)?.opacity ?? 1;
@@ -7009,7 +7138,7 @@ var RenderLoop = class {
         offCtx.save();
         this.marginViewport.applyRenderTransform(offCtx);
         for (const element of elements) {
-          const elBounds = getElementBounds(element);
+          const elBounds = getElementVisualBounds(element);
           if (elBounds && !boundsIntersect(elBounds, cullingRect)) continue;
           this.renderer.renderCanvasElement(offCtx, element);
         }
@@ -7075,9 +7204,37 @@ var RenderLoop = class {
     } else {
       this.lastGridRefs = [];
     }
+    for (const [order, elements] of hybridCanvasRuns) {
+      const hybridCtx = this.hybridSurface.getContext(order);
+      if (!hybridCtx) continue;
+      hybridCtx.clearRect(0, 0, this.canvasEl.width, this.canvasEl.height);
+      hybridCtx.save();
+      hybridCtx.scale(dpr, dpr);
+      hybridCtx.translate(this.camera.position.x, this.camera.position.y);
+      hybridCtx.scale(this.camera.zoom, this.camera.zoom);
+      for (const element of elements) {
+        const elBounds = getElementVisualBounds(element);
+        if (elBounds && !boundsIntersect(elBounds, cullingRect)) continue;
+        hybridCtx.save();
+        hybridCtx.globalAlpha = this.layerManager.getLayer?.(element.layerId)?.opacity ?? 1;
+        this.renderer.renderCanvasElement(hybridCtx, element);
+        hybridCtx.restore();
+      }
+      hybridCtx.restore();
+    }
     const overlayT0 = performance.now();
-    const activeTool = this.toolManager.activeTool;
-    if (activeTool?.renderOverlay) {
+    if (hybridActive && activeTool?.renderOverlay) {
+      const overlayCtx = this.hybridSurface.getContext(overlayOrder);
+      if (overlayCtx) {
+        overlayCtx.clearRect(0, 0, this.canvasEl.width, this.canvasEl.height);
+        overlayCtx.save();
+        overlayCtx.scale(dpr, dpr);
+        overlayCtx.translate(this.camera.position.x, this.camera.position.y);
+        overlayCtx.scale(this.camera.zoom, this.camera.zoom);
+        activeTool.renderOverlay(overlayCtx);
+        overlayCtx.restore();
+      }
+    } else if (activeTool?.renderOverlay) {
       activeTool.renderOverlay(ctx);
     }
     const overlayMs = performance.now() - overlayT0;
@@ -7828,8 +7985,11 @@ var Viewport = class {
     });
     this.wrapper = createWrapper();
     this.canvasEl = createCanvas();
+    this.paintStack = createPaintStack();
     this.domLayer = createDomLayer();
+    this.domLayer.style.zIndex = "2147483647";
     this.wrapper.appendChild(this.canvasEl);
+    this.wrapper.appendChild(this.paintStack);
     this.wrapper.appendChild(this.domLayer);
     this.container.appendChild(this.wrapper);
     this.toolContext = {
@@ -7899,11 +8059,12 @@ var Viewport = class {
       this.minimap.scheduleDraw();
     }
     this.domNodeManager = new DomNodeManager({
-      domLayer: this.domLayer,
+      domLayer: this.paintStack,
       onEditRequest: (id) => this.interactions.startEditingElement(id),
       isEditingElement: (id) => this.noteEditor.isEditing && this.noteEditor.editingElementId === id,
       getVersion: (id) => this.store.getVersion(id)
     });
+    this.domNodeManager.setCameraTransform(this.camera.toCSSTransform());
     this.interactMode = new InteractMode({
       getNode: (id) => this.domNodeManager.getNode(id)
     });
@@ -7924,7 +8085,8 @@ var Viewport = class {
       layerManager: this.layerManager,
       domNodeManager: this.domNodeManager,
       layerCache,
-      marginViewport: this.marginViewport
+      marginViewport: this.marginViewport,
+      hybridSurface: new HybridRenderSurface(this.paintStack)
     });
     this.unsubCamera = this.camera.onChange(() => {
       this.applyCameraTransform();
@@ -8011,6 +8173,7 @@ var Viewport = class {
   history;
   domLayer;
   canvasEl;
+  paintStack;
   wrapper;
   unsubCamera;
   unsubToolChange;
@@ -8366,7 +8529,9 @@ var Viewport = class {
     }
   }
   applyCameraTransform() {
-    this.domLayer.style.transform = this.camera.toCSSTransform();
+    const transform = this.camera.toCSSTransform();
+    this.domLayer.style.transform = transform;
+    this.domNodeManager.setCameraTransform(transform);
   }
   syncCanvasSize() {
     const rect = this.container.getBoundingClientRect();
@@ -11047,7 +11212,7 @@ var LaserTool = class {
 };
 
 // src/index.ts
-var VERSION = "0.52.0";
+var VERSION = "0.52.2";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ArrowTool,