@fundar/data-chart-telling 0.0.38 → 0.0.40

package/dist/plots/utils/labelOverflow.svelte.js

@@ -37,12 +37,21 @@ export function watchLabelOverflow(args) {
             catch {
                 return;
             }
-            const overflow = {
-                left: Math.ceil(Math.max(0, bounds.left - box.x)),
-                right: Math.ceil(Math.max(0, box.x + box.width - bounds.right)),
-                top: Math.ceil(Math.max(0, bounds.top - box.y)),
-                bottom: Math.ceil(Math.max(0, box.y + box.height - bounds.bottom)),
-            };
+            // An empty group (no labels currently rendered, e.g. every series is
+            // scrubbed/filtered out of view) reports getBBox() as (0,0,0,0) — the
+            // SVG origin, not "no content". Reading that literally as a box sitting
+            // at (0,0) would report overflow proportional to the *current* margins
+            // themselves, which grows them, which remounts this group against the
+            // new, larger bounds, which reports overflow again — an unbounded loop
+            // with nothing rendered to justify it.
+            const overflow = box.width === 0 && box.height === 0
+                ? NO_OVERFLOW
+                : {
+                    left: Math.ceil(Math.max(0, bounds.left - box.x)),
+                    right: Math.ceil(Math.max(0, box.x + box.width - bounds.right)),
+                    top: Math.ceil(Math.max(0, bounds.top - box.y)),
+                    bottom: Math.ceil(Math.max(0, box.y + box.height - bounds.bottom))
+                };
             attempt += 1;
             const stable = lastReading != null &&
                 lastReading.left === overflow.left &&
@@ -78,15 +87,48 @@ export function watchLabelOverflow(args) {
  * "shrink margin → overflow reappears → grow margin → …". Each side is only
  * ever set when the caller's own `margins` prop hasn't already pinned it, so
  * an explicit caller override always wins over this auto-grown one.
+ *
+ * That monotonic growth is only sound for a *stable* dataset — it assumes
+ * every reading describes the same thing being measured, just possibly at an
+ * earlier, not-yet-settled frame. It stops being sound once the caller's own
+ * data changes identity underneath it (e.g. a timeline scrubber revealing a
+ * different slice of rows on every tick): an overflow measured against
+ * *that* frame's rendered labels doesn't describe the next frame's, so
+ * carrying it forward forever can leave a plot permanently — and wrongly —
+ * margin-inflated by whatever the single most cluttered frame it ever
+ * passed through needed, long after scrubbing away from it. `resetKey`, if
+ * given, is compared by identity on every call; a change drops `measured`
+ * back to zero so the next frame's overflow is measured fresh against only
+ * what's actually on screen now. Pass whatever reactive value identifies
+ * "what's currently being plotted" for the caller (e.g. its own resolved
+ * series list) — a plain reference/value comparison, not a deep one, so it
+ * only need change identity when the rendered content actually does.
  */
-export function createLabelMarginTracker(margins) {
+export function createLabelMarginTracker(margins, resetKey) {
     let measured = $state(NO_OVERFLOW);
+    // Skips the reset on the very first run (there's nothing to reset yet,
+    // and `measured` already starts at `NO_OVERFLOW`) so only a later,
+    // genuine change to `resetKey` clears accumulated growth.
+    let resetKeyInitialized = false;
+    let lastResetKey;
+    $effect(() => {
+        const key = resetKey?.();
+        if (!resetKeyInitialized) {
+            resetKeyInitialized = true;
+            lastResetKey = key;
+            return;
+        }
+        if (key !== lastResetKey) {
+            lastResetKey = key;
+            measured = NO_OVERFLOW;
+        }
+    });
     function report(overflow) {
         const next = {
             left: Math.max(measured.left, overflow.left),
             right: Math.max(measured.right, overflow.right),
             top: Math.max(measured.top, overflow.top),
-            bottom: Math.max(measured.bottom, overflow.bottom),
+            bottom: Math.max(measured.bottom, overflow.bottom)
         };
         if (next.left !== measured.left ||
             next.right !== measured.right ||
@@ -126,11 +168,15 @@ export function createLabelMarginTracker(margins) {
     // must track.
     const plotProps = $derived.by(() => ({
         margins: resolvedMargins,
-        marginRemountKey: JSON.stringify(measured),
+        marginRemountKey: JSON.stringify(measured)
     }));
     return {
         report,
-        get resolvedMargins() { return resolvedMargins; },
-        get plotProps() { return plotProps; },
+        get resolvedMargins() {
+            return resolvedMargins;
+        },
+        get plotProps() {
+            return plotProps;
+        }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fundar/data-chart-telling",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "type": "module",
   "files": [
     "dist"