@beyondwork/docx-react-component 1.0.55 → 1.0.57

package/src/runtime/chart/chart-model-store.ts

@@ -3,13 +3,19 @@
  * Populated as a side effect of `surface-projection.ts` when a `chart_preview`
  * node carries `parsedData`. Consumed by `ChartNodeView` to render `ChartSurface`.
  *
- * Charts are preserve-only (rawXml never mutated), so entries are stable for the
- * lifetime of the document. `clear()` is called before repopulating on document
- * replacement.
+ * Charts are preserve-only (rawXml never mutated), so entries are stable for
+ * the lifetime of a given document build. Lifecycle management: each surface
+ * projection pass tags entries with an `owner` (the `CanonicalDocumentEnvelope`
+ * reference) and calls `retainForOwner(owner, seenIds)` at the end of the
+ * pass. This evicts (a) entries from previous documents (different owner),
+ * and (b) stale entries from earlier builds of the same document whose charts
+ * no longer appear. Without this, the store grew unbounded across document
+ * loads — a documented v1 gap before this fix.
  */
 
 import type { ChartModel } from "../../io/ooxml/chart/types.ts";
 import type { ResolvedTheme } from "../../model/canonical-document.ts";
+import { EMU_PER_PX } from "../units.ts";
 
 export interface ChartStoreEntry {
   readonly model: ChartModel;
@@ -19,16 +25,31 @@ export interface ChartStoreEntry {
 }
 
 const _store = new Map<string, ChartStoreEntry>();
+const _owners = new Map<string, object>();
+
+// Active build pass — set by `beginBuildPass(owner)` at the top of a
+// surface-projection call, consumed by `endBuildPass()` at the end. JS
+// is single-threaded; nested/concurrent projection passes on the same
+// tick aren't expected. Null when no pass is active.
+let _activeOwner: object | null = null;
+let _activeSeenIds: Set<string> | null = null;
 
 export const chartModelStore = {
   set(chartId: string, entry: ChartStoreEntry): void {
     _store.set(chartId, entry);
+    if (_activeOwner !== null) {
+      _owners.set(chartId, _activeOwner);
+      _activeSeenIds?.add(chartId);
+    }
   },
   get(chartId: string): ChartStoreEntry | undefined {
     return _store.get(chartId);
   },
   clear(): void {
     _store.clear();
+    _owners.clear();
+    _activeOwner = null;
+    _activeSeenIds = null;
   },
   size(): number {
     return _store.size;
@@ -39,9 +60,42 @@ export const chartModelStore = {
   values(): IterableIterator<ChartStoreEntry> {
     return _store.values();
   },
+  /**
+   * Open a build pass tagged with `owner` (typically the
+   * `CanonicalDocumentEnvelope` reference). Every `set(id, entry)` call
+   * until `endBuildPass()` records `owner` alongside the entry and adds
+   * `id` to the "seen this pass" set. Call exactly once at the top of
+   * `createEditorSurfaceSnapshot`.
+   */
+  beginBuildPass(owner: object): void {
+    _activeOwner = owner;
+    _activeSeenIds = new Set();
+  },
+  /**
+   * Close the build pass opened by `beginBuildPass`. Evicts every stored
+   * entry whose owner differs from the active one (charts from previous
+   * documents) AND every entry whose id wasn't seen in this pass (stale
+   * entries from earlier builds of the same document). Also records
+   * ownership for every `seenId` that was populated via `set` during the
+   * pass so subsequent `has(id)` short-circuits maintain correct owner
+   * metadata on fresh builds.
+   */
+  endBuildPass(): void {
+    const owner = _activeOwner;
+    const seen = _activeSeenIds;
+    _activeOwner = null;
+    _activeSeenIds = null;
+    if (owner === null || seen === null) return;
+    for (const id of [..._store.keys()]) {
+      const entryOwner = _owners.get(id);
+      if (entryOwner !== owner || !seen.has(id)) {
+        _store.delete(id);
+        _owners.delete(id);
+      }
+    }
+  },
 };
 
-const EMU_PER_PX = 9525;
 
 /**
  * Extract drawing extent from rawXml and convert EMU → pixels.
@@ -75,14 +129,23 @@ export function extractChartDimensions(rawXml: string): { widthPx: number; heigh
  * Stable chart ID derived from rawXml content. Charts are never mutated so the
  * ID is stable for the lifetime of the document load.
  *
- * Uses djb2 hash + length suffix to minimize collisions without importing a
- * crypto dependency.
+ * Uses a djb2 + FNV-1a dual 32-bit hash plus the length suffix. Concatenating
+ * two unrelated 32-bit hashes expands the effective collision space to ~2⁶⁴,
+ * which keeps the id safely unique even across documents with hundreds of
+ * charts. No crypto dependency required.
  */
 export function stableChartId(rawXml: string): string {
-  let h = 5381;
+  let h1 = 5381;          // djb2
+  let h2 = 0x811c9dc5;    // FNV-1a offset basis
   for (let i = 0; i < rawXml.length; i++) {
-    h = ((h << 5) + h) ^ rawXml.charCodeAt(i);
-    h = h | 0;
+    const c = rawXml.charCodeAt(i);
+    h1 = ((h1 << 5) + h1) ^ c;
+    h1 = h1 | 0;
+    h2 = (h2 ^ c) >>> 0;
+    // FNV prime 16777619 = 0x01000193; use Math.imul to stay in 32-bit.
+    h2 = Math.imul(h2, 0x01000193) >>> 0;
   }
-  return `chart-${(h >>> 0).toString(16)}-${rawXml.length}`;
+  const hex1 = (h1 >>> 0).toString(16).padStart(8, "0");
+  const hex2 = h2.toString(16).padStart(8, "0");
+  return `chart-${hex1}${hex2}-${rawXml.length}`;
 }