@wick-charts/vue 0.6.2 → 0.6.4

package/dist/core/dist/perf/perf-hud.js

@@ -10,7 +10,7 @@ function N(i) {
     ownsMonitor: !e
   };
 }
-const P = 100, z = 600, f = 250, F = 1e3 / 60, H = 1e3 / 120, m = 60, b = 4, j = 34, S = 64, L = 24;
+const P = 100, z = 600, f = 250, F = 1e3 / 60, H = 1e3 / 120, m = 60, b = 4, L = 34, S = 64, j = 24;
 function I(i) {
   let e = 0;
   for (const t of i)
@@ -233,7 +233,7 @@ class D {
     }), this.element.insertBefore(this.sparkHost, this.element.firstChild)) : (Object.assign(this.sparkHost.style, {
       position: "relative",
       inset: "auto",
-      height: `${j}px`,
+      height: `${L}px`,
       marginTop: "7px",
       borderRadius: "4px",
       opacity: "1",
@@ -308,7 +308,7 @@ class D {
   }
   /** Keeps the plateau below the FPS number (mini) or the Y tick (strip). */
   sparkPaddingTop() {
-    return this.mode === "mini" ? L : 12;
+    return this.mode === "mini" ? j : 12;
   }
   /** Append one FPS sample to the sparkline chart and roll its window. */
   appendSpark(e) {

package/dist/core/dist/scales/log-scale.js

@@ -0,0 +1,76 @@
+import { formatCompact as x } from "../utils/format.js";
+const b = 1e-9, p = /* @__PURE__ */ new Map();
+function K(n = {}) {
+  const t = n.base ?? 10;
+  if (!Number.isFinite(t) || t <= 0 || t === 1)
+    throw new Error(`[wick-charts] logScale: base must be a positive number other than 1, got ${t}.`);
+  const o = p.get(t);
+  if (o) return o;
+  const a = S(t);
+  return p.set(t, a), a;
+}
+function S(n) {
+  const t = Math.log(n), o = n === 10 ? Math.log10 : n === 2 ? Math.log2 : (r) => Math.log(r) / t, a = n === 10 ? [1, 2, 5] : [1];
+  return {
+    forward: o,
+    inverse: (r) => n ** r,
+    isPlottable: (r) => r > 0,
+    ticks: (r) => C(r, P({ ...r, forward: o, base: n, mantissas: a })),
+    format: (r) => B(x(r))
+  };
+}
+function C(n, t) {
+  const { linear: o, labelCount: a, height: r, minSpacing: l } = n;
+  if (o.length < 2) return t;
+  if (t.length < 2) return o;
+  const s = a ?? Math.max(2, Math.floor(r / l)), e = Math.abs(t.length - s);
+  return Math.abs(o.length - s) + 1 < e ? o : t;
+}
+function P(n) {
+  const { min: t, max: o, height: a, minSpacing: r, labelCount: l, forward: s, base: e, mantissas: i } = n, c = s(t), h = s(o), u = a / (h - c), f = k({ lo: c, hi: h, pxPerPower: u, minSpacing: r, labelCount: l, base: e });
+  if (f > 1) return w({ lo: c, hi: h, step: f, base: e });
+  const g = M({ lo: c, hi: h, base: e, mantissas: [1], forward: s });
+  if (i.length === 1) return g;
+  const $ = s(i[1]) - s(i[0]);
+  if (u * $ < r) return g;
+  const m = M({ lo: c, hi: h, base: e, mantissas: i, forward: s });
+  return l !== null && m.length > l ? g : m;
+}
+function k(n) {
+  const { lo: t, hi: o, pxPerPower: a, minSpacing: r, labelCount: l, base: s } = n;
+  let e = 1;
+  for (; e < 1e6; ) {
+    const i = e * a >= r, c = l === null || w({ lo: t, hi: o, step: e, base: s }).length <= l;
+    if (i && c) return e;
+    e = v(e);
+  }
+  return e;
+}
+function v(n) {
+  const t = n / 10 ** Math.floor(Math.log10(n));
+  return t < 2 ? n * 2 : t < 5 ? n * 2.5 : n * 2;
+}
+function w(n) {
+  const { lo: t, hi: o, step: a, base: r } = n, l = Math.ceil(t / a - b), s = Math.floor(o / a + b), e = [];
+  for (let i = l; i <= s; i++)
+    e.push(d(1, r, i * a));
+  return e;
+}
+function M(n) {
+  const { lo: t, hi: o, base: a, mantissas: r, forward: l } = n, s = Math.floor(t), e = Math.floor(o + b), i = [];
+  for (let c = s; c <= e; c++)
+    for (const h of r) {
+      const u = d(h, a, c), f = l(u);
+      f < t - b || f > o + b || i.push(u);
+    }
+  return i;
+}
+function d(n, t, o) {
+  return o >= 0 ? n * t ** o : n / t ** -o;
+}
+function B(n) {
+  return n.replace(/(\.\d*?)0+([KMBT]?)$/, "$1$2").replace(/\.([KMBT]?)$/, "$1");
+}
+export {
+  K as logScale
+};

package/dist/core/dist/scales/y-scale.js

@@ -6,17 +6,25 @@ function c(e) {
   const t = 10 ** Math.floor(Math.log10(e)), i = e / t;
   return (i <= 1 ? 1 : i <= 2 ? 2 : i <= 5 ? 5 : 10) * t;
 }
-function v(e) {
+function f(e) {
   if (!Number.isFinite(e) || e <= 0) return 1;
   const t = 10 ** Math.floor(Math.log10(e)), i = e / t;
   return (i >= 5 ? 5 : i >= 2 ? 2 : 1) * t;
 }
-const l = 50, f = 50;
-class T {
+const a = 50, v = 50;
+function g(e, t) {
+  return Number.isFinite(t) ? e?.isPlottable?.(t) ?? !0 : !1;
+}
+class d {
   /** Shared fade state for Y ticks; see {@link TimeScale.tickTracker}. */
   tickTracker = new m();
+  /** Non-linear value mapping (`axis.y.scale`); `null` is linear. */
+  transform = null;
   min = 0;
   max = 0;
+  /** Domain bounds in scale space — `transform.forward` of `min` / `max`. */
+  lo = 0;
+  hi = 0;
   height = 1;
   pixelRatio = 1;
   // Label density knobs — written by <YAxis labelCount=… minLabelSpacing=…>.
@@ -34,6 +42,8 @@ class T {
    * the boundary doesn't instantly flip back.
    */
   lastRawInterval = null;
+  /** The transform's own ticks (e.g. powers of ten); `null` while linear ticks are in use. */
+  ownTicks = null;
   /** Custom formatter (driven by `<YAxis format=…>`). */
   customFormat = null;
   /** Custom tick generator — bypasses {1,2,5}×10^k resolution in `niceTickValues` when set. */
@@ -42,23 +52,49 @@ class T {
     return this.labelCountHintValue;
   }
   get minLabelSpacing() {
-    return this.minSpacingValue ?? f;
+    return this.minSpacingValue ?? v;
   }
   /** Recalculate the scale with a new Y range, chart height, and device pixel ratio. */
-  update(t, i, a) {
-    this.min = t.min, this.max = t.max, this.height = i, this.pixelRatio = a, this.resolveInterval();
+  update(t, i, s) {
+    this.min = t.min, this.max = t.max, this.height = i, this.pixelRatio = s, this.updateDomain(), this.resolveTicks();
+  }
+  /** Install a non-linear value mapping, or `null` for linear. The range is kept as-is — the chart refits it. */
+  setTransform(t) {
+    t !== this.transform && (this.transform = t, this.resetHysteresis(), this.updateDomain(), this.resolveTicks());
+  }
+  getTransform() {
+    return this.transform;
+  }
+  /**
+   * Whether `value` has a position on this scale: finite, and inside the
+   * transform's domain (positive on log). Renderers skip values that fail —
+   * {@link valueToY} still maps them (to the plot floor) so nothing
+   * downstream sees NaN.
+   */
+  isPlottable(t) {
+    return g(this.transform, t);
   }
   /** Desired label count. Invalid values (NaN, <2, Infinity) clear the hint. */
   setLabelCount(t) {
-    this.labelCountHintValue = x(t), this.resetHysteresis(), this.resolveInterval();
+    this.labelCountHintValue = p(t), this.resetHysteresis(), this.resolveTicks();
   }
   /** Minimum pixel gap between adjacent labels. */
   setMinSpacing(t) {
-    this.minSpacingValue = p(t), this.resetHysteresis(), this.resolveInterval();
+    this.minSpacingValue = x(t), this.resetHysteresis(), this.resolveTicks();
   }
   resetHysteresis() {
     this.lastInterval = null, this.lastRawInterval = null;
   }
+  /** A transformed domain needs both bounds plottable; anything else collapses to a flat one. */
+  updateDomain() {
+    const t = this.transform;
+    if (t === null) {
+      this.lo = this.min, this.hi = this.max;
+      return;
+    }
+    const i = this.isPlottable(this.min) && this.isPlottable(this.max);
+    this.lo = i ? t.forward(this.min) : 0, this.hi = i ? t.forward(this.max) : 0;
+  }
   /** Install (or clear) a custom formatter. */
   setFormat(t) {
     this.customFormat = t;
@@ -75,10 +111,15 @@ class T {
   setTickGenerator(t) {
     this.customTickGenerator = t, this.resetHysteresis();
   }
-  /** Convert a value to a Y position in CSS (media) pixels. */
+  /**
+   * Convert a value to a Y position in CSS (media) pixels. A value the
+   * transform can't place (≤ 0 on log) lands on the plot floor.
+   */
   valueToY(t) {
-    const i = this.max - this.min;
-    return i === 0 ? this.height / 2 : (1 - (t - this.min) / i) * this.height;
+    const i = this.hi - this.lo;
+    if (i === 0) return this.height / 2;
+    const s = this.transform;
+    return s === null ? (1 - (t - this.lo) / i) * this.height : this.isPlottable(t) ? (1 - (s.forward(t) - this.lo) / i) * this.height : this.height;
   }
   /** Convert a value to a Y position in physical (bitmap) pixels, snapped to
    *  the pixel grid — for axis-aligned edges that have to stay crisp. */
@@ -101,21 +142,42 @@ class T {
   valueToSnappedY(t) {
     return (this.valueToBitmapY(t) + u(this.pixelRatio)) / this.pixelRatio;
   }
-  /** Convert a Y position in CSS pixels back to a value. */
+  /** Convert a Y position in CSS pixels back to a value — the exact inverse of {@link valueToY}. */
   yToValue(t) {
-    const i = this.max - this.min;
-    return i === 0 ? this.min : this.max - t / this.height * i;
+    const i = this.hi - this.lo;
+    if (i === 0) return this.min;
+    const s = this.hi - t / this.height * i;
+    return this.transform === null ? s : this.transform.inverse(s);
+  }
+  /** The value bars and stacks grow from: `0`, or the plot floor's value on a scale with no place for 0 (log). */
+  baselineValue() {
+    return this.isPlottable(0) ? 0 : this.min;
+  }
+  /**
+   * The value `t` of the way from `from` to `to` in pixels — a plain lerp on a
+   * linear axis, a geometric one on log. `t` past `[0, 1]` overshoots along the
+   * axis. An endpoint the transform can't place returns `to`, so a gap stays a gap.
+   */
+  lerpValue(t, i, s) {
+    const n = this.transform;
+    if (n === null) return t + (i - t) * s;
+    if (!this.isPlottable(t) || !this.isPlottable(i)) return i;
+    const r = n.forward(t);
+    return n.inverse(r + (n.forward(i) - r) * s);
   }
   /**
    * Generate evenly spaced "nice" tick values for the current range and
    * chart height. Pure read — resolution happens in `update()`.
    */
   niceTickValues() {
-    if (this.customTickGenerator) return this.customTickGenerator({ min: this.min, max: this.max }).slice(0, l);
+    return this.customTickGenerator ? this.customTickGenerator({ min: this.min, max: this.max }).slice(0, a) : this.ownTicks !== null ? this.ownTicks.slice(0, a) : this.linearTickValues();
+  }
+  /** {1,2,5}×10^k ticks at the resolved interval, limited to what the transform can place. */
+  linearTickValues() {
     if (this.resolvedInterval == null) return [];
-    const t = this.resolvedInterval, i = Math.ceil(this.min / t) * t, a = Math.max(0, Math.min(l, Math.floor((this.max - i) / t) + 1)), s = [];
-    for (let n = 0; n < a; n++) s.push(i + n * t);
-    return s;
+    const t = this.resolvedInterval, i = Math.ceil(this.min / t) * t, s = Math.max(0, Math.min(a, Math.floor((this.max - i) / t) + 1)), n = [];
+    for (let r = 0; r < s; r++) n.push(i + r * t);
+    return this.transform === null ? n : n.filter((r) => this.isPlottable(r));
   }
   getRange() {
     return { min: this.min, max: this.max };
@@ -132,13 +194,49 @@ class T {
    */
   formatY(t) {
     if (this.customFormat) return this.customFormat(t);
+    const i = this.ownTicks !== null ? this.transform?.format : void 0;
+    if (i) return i(t);
     if (this.max - this.min >= 1e6) return o(t);
-    const i = this.resolvedInterval, a = i != null && i > 0 ? Math.max(0, -Math.floor(Math.log10(i))) : 1;
-    return t.toFixed(a);
+    const s = this.resolvedInterval, n = s != null && s > 0 ? Math.max(0, -Math.floor(Math.log10(s))) : 1;
+    return t.toFixed(n);
+  }
+  resolveTicks() {
+    this.ownTicks = null;
+    const t = this.transform;
+    if (t === null) {
+      this.resolveInterval((this.max - this.min) * this.minLabelSpacing / this.height);
+      return;
+    }
+    const i = this.hi - this.lo;
+    if (!(i > 0) || this.height <= 0) {
+      this.resolvedInterval = null;
+      return;
+    }
+    if (this.resolveInterval(this.transformedGapFloor(t, i)), !t.ticks) return;
+    const s = this.linearTickValues(), n = t.ticks({
+      min: this.min,
+      max: this.max,
+      height: this.height,
+      minSpacing: this.minLabelSpacing,
+      labelCount: this.labelCountHint,
+      linear: s
+    });
+    this.ownTicks = n === s ? null : n;
+  }
+  /**
+   * Smallest linear interval whose ticks stay `minLabelSpacing` apart on the
+   * transformed axis. A monotonic mapping squeezes its gaps hardest at one
+   * end — the top for log (concave), the bottom for a convex one — so
+   * checking both ends covers it.
+   */
+  transformedGapFloor(t, i) {
+    const s = this.minLabelSpacing / this.height * i, n = this.max - t.inverse(Math.max(this.lo, this.hi - s)), r = t.inverse(Math.min(this.hi, this.lo + s)) - this.min;
+    return Math.max(n, r);
   }
   /**
    * Resolve the interval to a {1,2,5}×10^k tick size that satisfies the pixel
-   * floor and (optionally) targets `labelCountHint` labels.
+   * floor and (optionally) targets `labelCountHint` labels. `gapFloorValue` is
+   * the smallest interval that clears `minLabelSpacing` anywhere on the axis.
    *
    * Hysteresis: the band [0.8×, 1.25×] is anchored to **rawInterval at last
    * snap**, not to `lastInterval`. After an escalation (e.g. 100 → 200),
@@ -147,26 +245,26 @@ class T {
    * *not* de-escalate. This prevents the 2-tier flicker users see when new
    * candles nudge the Y range across a raw-interval threshold.
    */
-  resolveInterval() {
+  resolveInterval(t) {
     if (this.max <= this.min || this.height <= 0) {
       this.resolvedInterval = null;
       return;
     }
-    const t = this.max - this.min, i = t * this.minLabelSpacing / this.height, a = this.labelCountHint != null ? Math.max(1, this.labelCountHint) : Math.max(1, Math.floor(this.height / this.minLabelSpacing));
-    let s = t / a;
-    if (s < i && (s = i), this.lastInterval != null && this.lastRawInterval != null) {
-      const r = s >= this.lastRawInterval * 0.8 && s <= this.lastRawInterval * 1.25, h = this.lastInterval >= i;
-      if (r && h) {
+    const i = this.max - this.min, s = this.labelCountHint != null ? Math.max(1, this.labelCountHint) : Math.max(1, Math.floor(this.height / this.minLabelSpacing));
+    let n = i / s;
+    if (n < t && (n = t), this.lastInterval != null && this.lastRawInterval != null) {
+      const l = n >= this.lastRawInterval * 0.8 && n <= this.lastRawInterval * 1.25, h = this.lastInterval >= t;
+      if (l && h) {
         this.resolvedInterval = this.lastInterval;
         return;
       }
     }
-    let n = c(s);
-    if (this.labelCountHint != null && this.countTicks(n) < this.labelCountHint) {
-      const r = v(s);
-      r >= i && r > 0 && (n = r);
+    let r = c(n);
+    if (this.labelCountHint != null && this.countTicks(r) < this.labelCountHint) {
+      const l = f(n);
+      l >= t && l > 0 && (r = l);
     }
-    this.resolvedInterval = n, this.lastInterval = n, this.lastRawInterval = s;
+    this.resolvedInterval = r, this.lastInterval = r, this.lastRawInterval = n;
   }
   countTicks(t) {
     if (!(t > 0)) return 0;
@@ -174,12 +272,13 @@ class T {
     return Math.max(0, Math.floor((this.max - i) / t) + 1);
   }
 }
-function x(e) {
+function p(e) {
   return typeof e == "number" && Number.isFinite(e) && e >= 2 ? Math.floor(e) : null;
 }
-function p(e) {
+function x(e) {
   return typeof e == "number" && Number.isFinite(e) && e > 0 ? e : null;
 }
 export {
-  T as YScale
+  d as YScale,
+  g as isPlottableOn
 };