@spider-analyzer/timeline 5.0.4 → 5.0.6

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 5.0.6
+
+- Fix: don't issue the first `onLoadHisto` with a stale `intervalMs`
+  when the consumer hasn't measured a valid width yet. `getItems` now
+  short-circuits the fetch while `histoWidth <= 0`, and the width-change
+  effect re-runs `getItems` whenever a domain exists (not only when the
+  prior call marked `isActive=true`). Previously the first call fired
+  with `histoWidth=0`, fell back to `domainSpan / 1 tick` and divided by
+  `barsBetweenTicks` — giving a coarse interval like 3 h over a 24 h
+  window; the subsequent width arrival then never retriggered the load
+  because `isActive` was already true and the delta check failed.
+
+## 5.0.5
+
+- Fix: compute intervalMs defensively in `getItems`. When d3's
+  `xAxis.ticks(N)` momentarily returned fewer than 2 entries (sparse
+  tick generation during the first render, while layout is still
+  settling), the previous code did `moment(ticks[1]).diff(moment(ticks[0]))`
+  with `ticks[1]` undefined. `moment(undefined)` is "now", so the diff
+  went negative, `_max` picked `smallestResolution`, and the very first
+  `onLoadHisto` asked for a 15 ms resolution over the whole domain —
+  flooding the backend. Any subsequent gesture (scroll, resize) produced
+  a correct interval, matching the user-observed "scrolling fixes it"
+  behavior.
+
+  Fix: when ticks are sparse, fall back to `domainSpan / tickCount`
+  instead of trusting ticks[1]−ticks[0]. Same nice-interval behavior on
+  the happy path, no regression when d3 hasn't produced enough ticks.
+
 ## 5.0.4
 
 - Fix: memoize the moment-typed props built by the outer TimeLine

package/dist/index.js

@@ -2081,13 +2081,15 @@ var TimeLineInner = react.forwardRef(function TimeLine(props, ref) {
     const xAxis = d3Scale.scaleTime().domain([domain2.min, domain2.max]).range([0, histoWidth2]);
     xAxis.clamp(true);
     xAxisRef.current = xAxis;
-    const ticks2 = xAxis.ticks(floor(histoWidth2 / p.xAxis.spaceBetweenTicks));
+    const tickCount = floor(histoWidth2 / p.xAxis.spaceBetweenTicks);
+    const ticks2 = xAxis.ticks(tickCount);
+    const tickIntervalMs = ticks2.length >= 2 ? ticks2[1].getTime() - ticks2[0].getTime() : (+domain2.max - +domain2.min) / Math.max(tickCount, 1);
     const intervalMs = max([
-      round(moment_shim_default(ticks2[1]).diff(moment_shim_default(ticks2[0])) / p.xAxis.barsBetweenTicks),
+      round(tickIntervalMs / p.xAxis.barsBetweenTicks),
       propsRef.current.smallestResolution.asMilliseconds()
     ]);
     patchState({ histoWidth: histoWidth2, isActive: true, ticks: ticks2 });
-    if (shouldReload && intervalMs) {
+    if (shouldReload && intervalMs && histoWidth2 > 0) {
       widthOfLastUpdateRef.current = p.width;
       patchState({ waitForLoad: true });
       p.onLoadHisto(intervalMs, domain2.min, domain2.max);
@@ -2117,12 +2119,11 @@ var TimeLineInner = react.forwardRef(function TimeLine(props, ref) {
       return;
     }
     const s = stateRef.current;
-    if (s.isActive) {
+    patchState(computeMarginAndWidth(props));
+    if (s.domain) {
       const big = widthOfLastUpdateRef.current !== null && Math.abs((props.width ?? 0) - (widthOfLastUpdateRef.current ?? 0)) > 30;
-      getItems(props, s.domain, big);
-      patchState(computeMarginAndWidth(props));
-    } else {
-      patchState(computeMarginAndWidth(props));
+      const shouldReload = !s.isActive || big || widthOfLastUpdateRef.current === null;
+      getItems(props, s.domain, shouldReload);
     }
     if (stateRef.current.domain) {
       const res = checkAndCorrectDomain({ domain: stateRef.current.domain });