@wick-charts/vue 0.4.2 → 0.5.1

package/dist/core/dist/chart/fit-to-data.js

@@ -0,0 +1,9 @@
+import { resolvePaddingTime as l } from "./viewport-padding.js";
+function g(c) {
+  const { firstTime: r, lastTime: a, dataInterval: t, maxVisibleBars: p, chartWidth: o, padding: m } = c, s = p * t, n = a - r, d = n > 0 ? n : t * 10, f = l(m.right, d, t, o), h = l(m.left, d, t, o);
+  let i = a + f, e = r - h;
+  return i - e > s && (i = a + f, e = i - s), { from: e, to: i };
+}
+export {
+  g as computeFitToData
+};

package/dist/core/dist/chart/last-value.js

@@ -0,0 +1,31 @@
+const a = (e) => "close" in e ? e.close : e.value;
+function f(e, i, l) {
+  const t = i.find((c) => c.id === e);
+  if (!t) return null;
+  const n = t.renderer;
+  if (n.kind === "pie") return null;
+  const r = n.getLastDataPoint();
+  if (!r) return null;
+  const { from: u, to: o } = l;
+  if (r.time >= u && r.time <= o)
+    return { value: a(r), isLive: !0 };
+  const s = n.getVisibleDataPoints(u, o);
+  return s.length === 0 ? null : { value: a(s[s.length - 1]), isLive: !1 };
+}
+function d(e, i, l) {
+  const t = i.find((r) => r.id === e);
+  return t ? t.renderer.getStackedLastValue?.() || f(e, i, l) : null;
+}
+function g(e, i) {
+  const l = i.find((r) => r.id === e);
+  if (!l) return null;
+  const t = l.renderer;
+  if (t.kind === "pie") return null;
+  const n = t.getSecondLastDataPoint();
+  return n ? "close" in n ? n.close : n.value : null;
+}
+export {
+  f as getLastValue,
+  g as getPreviousClose,
+  d as getStackedLastValue
+};

package/dist/core/dist/chart/options.js

@@ -0,0 +1,35 @@
+import { DEFAULT_MAX_VISIBLE_BARS as o, MIN_VISIBLE_BARS as n } from "./pan-zoom-math.js";
+function s(t) {
+  if (!t) return { monitor: null, ownsMonitor: !1, hud: null };
+  if (typeof t != "object" || !("monitor" in t || "recordFrame" in t))
+    throw new Error(
+      "[wick-charts] The `perf: true` / option-object forms were replaced by config factories — pass `perf: perfHud()` for a monitor with the HUD overlay, or a `PerfMonitor` instance for HUD-less instrumentation. Importing the factory is what pulls perf code into the bundle."
+    );
+  return "recordFrame" in t ? { monitor: t, ownsMonitor: !1, hud: null } : { monitor: t.monitor, ownsMonitor: t.ownsMonitor ?? !1, hud: t.hud ?? null };
+}
+const r = {
+  top: 20,
+  bottom: 20,
+  right: { intervals: 3 },
+  left: { intervals: 0 }
+};
+function a(t) {
+  return {
+    top: t?.top ?? r.top,
+    bottom: t?.bottom ?? r.bottom,
+    right: t?.right ?? r.right,
+    left: t?.left ?? r.left
+  };
+}
+function f(t, e) {
+  return typeof t == "number" && typeof e == "number" ? t === e : typeof t == "object" && typeof e == "object" ? t.intervals === e.intervals : !1;
+}
+function l(t) {
+  return t === void 0 ? o : Number.isFinite(t) ? Math.max(n, Math.floor(t)) : o;
+}
+export {
+  f as isSameHorizontalPadding,
+  l as resolveMaxVisibleBars,
+  a as resolvePadding,
+  s as resolvePerfOptions
+};

package/dist/core/dist/chart/pan-zoom-math.js

@@ -0,0 +1,66 @@
+import { resolvePaddingTime as S } from "./viewport-padding.js";
+const T = 200, w = 2;
+function L(i) {
+  const { range: c, chartWidth: n, dataInterval: d, padding: r, dataStart: a, dataEnd: e } = i, t = (u) => typeof u == "object" || u === 0 || n > 0, f = a !== null && t(r.left) ? a - S(r.left, c, d, n) : null, s = e !== null && t(r.right) ? e + S(r.right, c, d, n) : null;
+  return { left: f, right: s };
+}
+function b(i) {
+  return 10 * i;
+}
+function y(i) {
+  const { dataInterval: c, padding: n, dataStart: d, dataEnd: r } = i;
+  if (d === null || r === null) return null;
+  const a = r - d;
+  if (a <= 0) return null;
+  const e = typeof n.left == "object" ? n.left.intervals * c : null, t = typeof n.right == "object" ? n.right.intervals * c : null;
+  return e !== null || t !== null ? a + (e ?? 0) + (t ?? 0) : a + c * 5;
+}
+function R(i) {
+  return i * 0.5;
+}
+function A(i) {
+  const { currentLogical: c, timeDelta: n, chartWidth: d, dataInterval: r, padding: a, dataStart: e, dataEnd: t } = i, { from: f, to: s } = c;
+  if (s - f <= 0)
+    return { newLogical: null, autoScrollOff: !1, edgeReached: null };
+  let u = f + n, o = s + n, g = null;
+  if (t !== null && u > t) {
+    const l = u - t;
+    u -= l, o -= l, g = { side: "right", overshoot: l, boundaryTime: t };
+  }
+  if (e !== null && o < e) {
+    const l = e - o;
+    u += l, o += l, g = { side: "left", overshoot: l, boundaryTime: e };
+  }
+  const p = t !== null && (typeof a.right == "object" || a.right === 0 || d > 0) ? S(a.right, o - u, r, d) : 0, m = R(r), h = t !== null && Math.abs(o - (t + p)) < m;
+  return {
+    newLogical: { from: u, to: o },
+    autoScrollOff: !h,
+    edgeReached: g
+  };
+}
+function B(i) {
+  const { currentLogical: c, centerTime: n, factor: d, chartWidth: r, dataInterval: a, padding: e, dataStart: t, dataEnd: f } = i, { from: s, to: u } = c, o = u - s;
+  if (o <= 0)
+    return { newLogical: null };
+  const g = b(a), { left: p, right: m } = L({
+    range: o,
+    chartWidth: r,
+    dataInterval: a,
+    padding: e,
+    dataStart: t,
+    dataEnd: f
+  }), h = p !== null && m !== null ? m - p : y({ dataInterval: a, padding: e, dataStart: t, dataEnd: f });
+  let l = o * d;
+  l < g && (l = g), d > 1 && h !== null && l > h && (l = h);
+  const I = (n - s) / o, v = n - I * l, E = v + l;
+  return { newLogical: { from: v, to: E } };
+}
+export {
+  T as DEFAULT_MAX_VISIBLE_BARS,
+  w as MIN_VISIBLE_BARS,
+  A as computePan,
+  L as computeSoftBounds,
+  B as computeZoom,
+  y as softMaxRange,
+  b as softMinRange
+};

package/dist/core/dist/chart/streaming-cadence.js

@@ -0,0 +1,70 @@
+class i {
+  #t = 0;
+  #s = 0;
+  /** Fold a new arrival into the EMA. Pass `performance.now()` from the host. */
+  observe(s) {
+    if (this.#t > 0) {
+      const t = s - this.#t;
+      t >= 5 && t < 5e3 && (this.#s = this.#s === 0 ? t : 0.3 * t + (1 - 0.3) * this.#s);
+    }
+    this.#t = s;
+  }
+  /**
+   * Reset the inter-arrival tracker without dropping the EMA. The next
+   * `observe()` is treated as a session restart so a skipped-tick window
+   * (e.g. ViewportEngine gesture lock-out) doesn't poison the EMA with the
+   * gap-during-gesture wall-time. EMA is preserved so the post-gesture
+   * cadence picks up where streaming left off.
+   */
+  pause() {
+    this.#t = 0;
+  }
+  /**
+   * Seed the inter-arrival baseline to a known wall-clock time so the *next*
+   * `observe()` folds a real gap into the EMA. Without this, the first
+   * streaming append after an initial load (or a bulk replace) has no prior
+   * arrival to measure against: `observe` sets the baseline but folds nothing,
+   * the EMA stays 0, and `pickSettleMs` returns the bare `floor`. That makes
+   * the first X slide settle in `floor` ms — a bell curve that accelerates,
+   * peaks, then stops — while every later tick rides the cadence-tuned settle
+   * and slides continuously. The visible artifact is "stutter on the first
+   * point, smooth from the second". Seeding at paint time lets the first
+   * append pick up the producer cadence immediately.
+   *
+   * Unlike `pause()` (which clears the baseline to 0 so the next gap is
+   * suppressed), this SETS a fresh baseline. It never folds a sample, so
+   * calling it on back-to-back replaces can't poison the EMA.
+   */
+  seed(s) {
+    this.#t = s;
+  }
+  /**
+   * Pick a settle time for the X spring sized to the current cadence. The
+   * spring should still be mid-flight when the next data tick arrives —
+   * otherwise its velocity decays toward zero between ticks and the slide
+   * reads as a bell-curve pulse (accelerate → peak → decelerate → restart).
+   *
+   * `floor` is the user-configured baseline (typically `animations.axis.x.settle`);
+   * returned value is `max(floor, ema * slack)` clamped at {@link SETTLE_MS_MAX}.
+   * The `slack` multiplier (default 3.0) means the spring's 99 %-settle
+   * window is ~3 × the measured cadence — at any one tick the spring is at
+   * roughly the 1/3 point of its decay, with significant velocity that
+   * carries seamlessly into the next retarget. Lower slack (e.g., 1.2)
+   * leaves the spring closer to settled by the next tick and reintroduces
+   * the bell-curve pulse; higher slack (e.g., 5) tightens the visual lag
+   * but makes the slide feel laggier behind the live tail.
+   */
+  pickSettleMs(s, t = 3) {
+    return this.#s === 0 ? s : Math.min(5e3, Math.max(s, this.#s * t));
+  }
+  /**
+   * Current EMA value. Hidden behind a getter to keep state read-only.
+   * @internal Test-only; not part of the production API.
+   */
+  get emaMs() {
+    return this.#s;
+  }
+}
+export {
+  i as StreamingCadence
+};

package/dist/core/dist/chart/streaming-target.js

@@ -0,0 +1,22 @@
+import { resolvePaddingTime as M } from "./viewport-padding.js";
+const S = 0.5, w = 4;
+function v(s) {
+  const { currentLogical: u, lastTime: i, prevDataEnd: c, dataInterval: t, paddingRight: d, chartWidth: a, holdUntilFilled: r } = s, { from: m, to: e } = u, l = e - m;
+  if (l <= 0)
+    return { newLogical: null, releaseHold: !1, reengageAutoScroll: !1 };
+  const o = M(d, l, t, a);
+  if (r) {
+    const H = t * 0.01;
+    if (i + o <= e + H)
+      return { newLogical: null, releaseHold: !1, reengageAutoScroll: !0 };
+  }
+  const f = c !== null ? e - c : o, h = Math.max(0, Math.min(o, f)), n = i + h, p = n - l, g = S * t, L = a > 0 ? w / a * l : g, A = Math.min(g, L);
+  return Math.abs(n - e) < A ? { newLogical: null, releaseHold: r, reengageAutoScroll: !0 } : {
+    newLogical: { from: p, to: n },
+    releaseHold: r,
+    reengageAutoScroll: !0
+  };
+}
+export {
+  v as computeStreamingTarget
+};

package/dist/core/dist/chart/viewport-padding.js

@@ -0,0 +1,6 @@
+function o(e, i, n, t) {
+  return typeof e == "object" ? e.intervals * n : t <= 0 ? 0 : e / t * i;
+}
+export {
+  o as resolvePaddingTime
+};

package/dist/core/dist/chart/y-target.js

@@ -0,0 +1,24 @@
+function f(e, r, u) {
+  let o = 1 / 0, a = -1 / 0;
+  for (const n of r) {
+    if (!n.visible || n.renderer.kind === "pie") continue;
+    const t = n.renderer.getValueRange(e.from, e.to);
+    t && (t.max > a && (a = t.max), t.min < o && (o = t.min), u?.push(t.min, t.max));
+  }
+  return o === 1 / 0 || a === -1 / 0 ? null : { min: o, max: a };
+}
+function m(e, r, u, o, a) {
+  if (e === void 0 || e === "auto") return r;
+  if (typeof e == "number") return e;
+  if (typeof e == "function") return e(o);
+  const n = String(e).match(/^([+-]?)\s*(\d+(?:\.\d+)?)\s*%$/);
+  if (n) {
+    const t = n[1] === "-" ? -1 : 1, i = parseFloat(n[2]) / 100, s = Math.abs(u - r) || Math.abs(r) || 1;
+    return r + t * i * s * (a === "max" ? 1 : -1);
+  }
+  return r;
+}
+export {
+  f as computeTargetYRange,
+  m as resolveBound
+};