@wick-charts/vue 0.4.2 → 0.5.1

package/dist/core/dist/series/line.js

@@ -0,0 +1,446 @@
+import { DEFAULT_LINE_PULSE as et, DEFAULT_LINE_SMOOTH as it, DEFAULT_LINE_ENTRY as ot } from "../animation/config.js";
+import { easeOutCubic as J } from "../animation/easing.js";
+import { decimateLineData as K } from "../data/decimation.js";
+import { hexToRgba as D } from "../utils/color.js";
+import { lerp as U } from "../utils/math.js";
+import { BaseMultiLayerSeries as nt } from "./base-multi-layer.js";
+import { buildCurveSegments as Q } from "./painters/canvas-path.js";
+import { resolveLinePainter as lt } from "./painters/resolve.js";
+const rt = {
+  colors: ["#2962FF"],
+  strokeWidth: 1,
+  area: { visible: !0 },
+  pulse: !0,
+  stacking: "off",
+  curve: "straight",
+  entryMs: ot,
+  smoothMs: it,
+  pulseMs: et
+};
+function Z(v) {
+  const t = v.areaFill, e = t !== void 0 && v.area === void 0 ? { visible: !!t } : v.area;
+  return {
+    ...v,
+    area: e,
+    entryMs: v.entryMs === !1 ? 0 : v.entryMs ?? ot,
+    smoothMs: v.smoothMs === !1 ? 0 : v.smoothMs ?? it,
+    pulseMs: v.pulseMs === !1 ? 0 : v.pulseMs ?? et
+  };
+}
+function $(v) {
+  return v.map(([t, e]) => ({ x: t, y: e }));
+}
+function tt(v, t) {
+  for (const e of t)
+    e.kind === "line" ? v.lineTo(e.x, e.y) : v.bezierCurveTo(e.cp1x, e.cp1y, e.cp2x, e.cp2y, e.x, e.y);
+}
+function at(v, t, e) {
+  for (let s = e.length - 1; s >= 0; s--) {
+    const r = e[s], n = s > 0 ? e[s - 1] : t[0];
+    r.kind === "line" ? v.lineTo(n.x, n.y) : v.bezierCurveTo(r.cp2x, r.cp2y, r.cp1x, r.cp1y, n.x, n.y);
+  }
+}
+class ht extends nt {
+  kind = "line";
+  areaGradientCache = /* @__PURE__ */ new Map();
+  constructor(t, e) {
+    super(t), this.options = Z({ ...rt, ...e });
+  }
+  updateOptions(t) {
+    this.options = Z({ ...this.options, ...t });
+  }
+  getStacking() {
+    return this.options.stacking;
+  }
+  applyTheme(t, e) {
+    const s = this.stores.length === 1 ? [t.line.color] : t.seriesColors.slice(0, this.stores.length);
+    this.updateOptions({ colors: s }), this.options.strokeWidth === e.line.width && this.updateOptions({ strokeWidth: t.line.width });
+  }
+  isEntryEnabled() {
+    return (this.options.entryAnimation ?? "grow") !== "none";
+  }
+  get hasPulse() {
+    return this.options.pulse && this.options.pulseMs > 0 && this.stores.some((t) => t.isVisible() && t.length > 0);
+  }
+  get overlayNeedsAnimation() {
+    return this.hasPulse;
+  }
+  hasOverlayContentInRange(t, e) {
+    for (let s = 0; s < this.stores.length; s++) {
+      if (this.getLayerAlpha(s) <= 0) continue;
+      const r = this.stores[s].last();
+      if (r && r.time >= t) return !0;
+    }
+    return !1;
+  }
+  render(t) {
+    this.tickAnimations(performance.now()), this.options.stacking === "off" ? this.renderOff(t) : this.renderStacked(t, this.options.stacking === "percent");
+  }
+  /**
+   * Rendered positions of the layer's still-unsettled trailing points, keyed
+   * by time. Each chain link lerps from the *previous link's rendered
+   * position* toward its own target — so when appends arrive faster than
+   * `entryMs` and several entrances overlap, the older heads keep unfurling
+   * instead of snapping to their raw spots the frame a new point lands.
+   *
+   * Targets read {@link BaseMultiLayerSeries.effectiveValue}, so the pinned
+   * live chase and the entrance compose. Returns `null` when nothing is
+   * unsettled or any value in the chain (anchor included) is non-finite —
+   * callers fall back to raw geometry, mirroring the old NaN guard.
+   */
+  chainedTailPositions(t, e) {
+    const s = this.unsettledTail(t, e);
+    if (s.length === 0) return null;
+    const r = this.stores[e].getAll(), n = r.length - 1 - s.length;
+    if (n < 0) return null;
+    const { timeScale: l, yScale: d } = t, L = r[n];
+    if (!Number.isFinite(L.value)) return null;
+    let k = l.timeToBitmapX(L.time), B = d.valueToBitmapY(this.effectiveValue(t, e, L.time, L.value));
+    const f = /* @__PURE__ */ new Map();
+    for (let m = 0; m < s.length; m++) {
+      const h = r[n + 1 + m];
+      if (!Number.isFinite(h.value)) return null;
+      const P = J(s[m].progress), o = l.timeToBitmapX(h.time), C = d.valueToBitmapY(this.effectiveValue(t, e, h.time, h.value)), y = U(k, o, P), g = U(B, C, P);
+      f.set(h.time, { x: y, y: g }), k = y, B = g;
+    }
+    return f;
+  }
+  /**
+   * Bitmap coordinates for the trailing endpoint of a layer — i.e. where the
+   * last visible point should be drawn *right now*. Accounts for live-tracking
+   * smoothing on Y (via {@link BaseMultiLayerSeries.effectiveValue}) and the
+   * `'grow'` entrance animation via the chained tail lerp.
+   *
+   * Shared between `renderOff` (last `lineTo` of the polyline) and `drawOverlay`
+   * (pulse dot) so the pulse glides in sync with the trailing segment instead
+   * of teleporting to the raw last.time while the line still unfurls.
+   */
+  trailingEndpoint(t, e) {
+    const s = this.stores[e].last();
+    if (!s) return null;
+    const { timeScale: r, yScale: n } = t, l = r.timeToBitmapX(s.time), d = n.valueToBitmapY(this.effectiveValue(t, e, s.time, s.value));
+    return (this.options.entryAnimation ?? "grow") !== "grow" ? { x: l, y: d } : this.chainedTailPositions(t, e)?.get(s.time) ?? { x: l, y: d };
+  }
+  /**
+   * Vertical stroke + area gradients for `options.threshold`, pinned to the
+   * threshold value's pixel row so the series reads calm below the level and hot
+   * above it. Returns `null` when no threshold is configured.
+   *
+   * Recomputed per frame: `createLinearGradient` is cheap, and the row drifts as
+   * the Y-axis autoscales (and during the spike's entrance), so a cache keyed on
+   * the row would miss almost every frame anyway.
+   */
+  buildThresholdPaint(t, e) {
+    const s = this.options.threshold;
+    if (!s) return null;
+    const { scope: r, yScale: n } = t, { context: l } = r, d = r.bitmapSize.height, L = s.above, k = s.below ?? e, B = Math.min(1, Math.max(0, n.valueToBitmapY(s.value) / d)), f = Math.min(6 * r.verticalPixelRatio, d * 0.02) / d, m = Math.max(0, B - f), h = Math.min(1, B + f), P = l.createLinearGradient(0, 0, 0, d);
+    P.addColorStop(0, L), P.addColorStop(m, L), P.addColorStop(h, k), P.addColorStop(1, k);
+    const o = l.createLinearGradient(0, 0, 0, d);
+    return o.addColorStop(0, D(L, 0.26)), o.addColorStop(m, D(L, 0.14)), o.addColorStop(h, D(k, 0.1)), o.addColorStop(1, D(k, 0.01)), { stroke: P, area: o };
+  }
+  /** Each layer drawn independently */
+  renderOff(t) {
+    const { scope: e, timeScale: s, yScale: r } = t, { context: n } = e, l = s.getRange(), { verticalPixelRatio: d } = e, L = this.options.strokeWidth > 0, k = Math.max(1, Math.round(this.options.strokeWidth * d)), B = this.options.entryAnimation ?? "grow", f = lt(this.options.linePainter ?? this.options.curve ?? "straight"), m = {
+      ctx: n,
+      theme: t.theme,
+      horizontalPixelRatio: e.horizontalPixelRatio,
+      verticalPixelRatio: d
+    };
+    for (let h = 0; h < this.stores.length; h++) {
+      const P = this.getLayerAlpha(h);
+      if (P <= 0) continue;
+      let o = this.stores[h].getVisibleData(l.from, l.to);
+      const C = e.mediaSize.width;
+      if (o.length > C * 2 && (o = K(o, Math.round(C * 1.5))), o.length < 2) continue;
+      const y = this.stores[h].last()?.value ?? o[o.length - 1].value, g = this.resolveLayerColor(h, y), I = this.buildThresholdPaint(t, g), E = o[o.length - 1], b = this.stores[h].last(), W = b !== void 0 && E.time === b.time, Y = W ? this.entranceProgress(t, h, E.time) : 1, N = W && B === "fade" && Y < 1, T = (W ? this.trailingEndpoint(t, h) : null) ?? {
+        x: s.timeToBitmapX(E.time),
+        y: r.valueToBitmapY(this.effectiveValue(t, h, E.time, E.value))
+      }, z = T.x, i = T.y, c = W && B === "grow" ? this.chainedTailPositions(t, h) : null, a = P < 1;
+      (a || N) && (n.save(), a && (n.globalAlpha *= P), N && (n.globalAlpha *= Y));
+      const S = o.length - 1, p = [];
+      let x = null;
+      for (let u = 0; u < S; u++) {
+        const w = o[u].value;
+        if (!Number.isFinite(w)) {
+          x = null;
+          continue;
+        }
+        x || (x = [], p.push(x));
+        const A = c?.get(o[u].time);
+        if (A)
+          x.push({ x: A.x, y: A.y });
+        else {
+          const O = r.valueToBitmapY(this.effectiveValue(t, h, o[u].time, w));
+          x.push({ x: s.timeToBitmapX(o[u].time), y: O });
+        }
+      }
+      const F = o[S]?.value, _ = Number.isFinite(z) && Number.isFinite(i) && Number.isFinite(F), H = B === "grow" && Y < 1;
+      let X = null;
+      if (_ && (x ? (x.push({ x: z, y: i }), X = x) : p.push([{ x: z, y: i }])), L && p.some((u) => u.length >= 2)) {
+        n.beginPath();
+        for (const u of p)
+          u.length < 2 || f(m, { points: u, color: g, lineWidth: k, closing: !1, grew: H && u === X });
+        n.strokeStyle = I ? I.stroke : g, n.lineWidth = k, n.lineJoin = "round", n.lineCap = "round", n.stroke();
+      }
+      if (L) {
+        const u = Math.max(1, k / 2);
+        let w = !1;
+        for (const A of p)
+          A.length === 1 && (w || (n.beginPath(), w = !0), n.moveTo(A[0].x + u, A[0].y), n.arc(A[0].x, A[0].y, u, 0, Math.PI * 2));
+        w && (n.fillStyle = g, n.fill());
+      }
+      if (this.options.area.visible) {
+        const u = e.bitmapSize.height;
+        let w;
+        if (I)
+          w = I.area;
+        else {
+          const A = String(h), O = this.areaGradientCache.get(A);
+          O && O.bottomY === u && O.color === g ? w = O.gradient : (w = n.createLinearGradient(0, 0, 0, u), w.addColorStop(0, D(g, 0.12)), w.addColorStop(1, D(g, 0.01)), this.areaGradientCache.set(A, { gradient: w, bottomY: u, color: g }));
+        }
+        n.fillStyle = w;
+        for (const A of p)
+          A.length < 2 || (n.beginPath(), f(m, { points: A, color: g, lineWidth: k, closing: !0, grew: H && A === X }), n.lineTo(A[A.length - 1].x, u), n.lineTo(A[0].x, u), n.closePath(), n.fill());
+      }
+      (N || a) && n.restore();
+    }
+  }
+  /** Stacked area rendering */
+  renderStacked(t, e) {
+    const { scope: s, timeScale: r, yScale: n } = t, { context: l } = s, d = r.getRange(), { verticalPixelRatio: L } = s, k = this.options.strokeWidth > 0, B = Math.max(1, Math.round(this.options.strokeWidth * L)), f = this.options.curve ?? "straight", m = s.mediaSize.width, h = this.stores.map((i, c) => {
+      if (this.getLayerAlpha(c) <= 0) return [];
+      let a = i.getVisibleData(d.from, d.to);
+      return a.length > m * 2 && (a = K(a, Math.round(m * 1.5))), a;
+    }), P = /* @__PURE__ */ new Set();
+    for (const i of h)
+      for (const c of i) P.add(c.time);
+    const o = Array.from(P).sort((i, c) => i - c);
+    if (o.length < 2) return;
+    const C = h.map((i, c) => {
+      const a = /* @__PURE__ */ new Map(), S = this.getLayerAlpha(c);
+      for (const p of i) a.set(p.time, this.effectiveValue(t, c, p.time, p.value) * S);
+      return a;
+    }), y = Array.from({ length: this.stores.length }, () => new Array(o.length).fill(0));
+    for (let i = 0; i < o.length; i++) {
+      const c = o[i];
+      let a = 0;
+      if (e)
+        for (let p = 0; p < this.stores.length; p++) {
+          const x = C[p].get(c);
+          Number.isFinite(x) && (a += x);
+        }
+      let S = 0;
+      for (let p = 0; p < this.stores.length; p++) {
+        const x = C[p].get(c), F = Number.isFinite(x) ? x : 0;
+        S += e && a > 0 ? F / a * 100 : F, y[p][i] = S;
+      }
+    }
+    const g = this.options.entryAnimation ?? "grow", I = /* @__PURE__ */ new Map();
+    for (let i = 0; i < o.length; i++) I.set(o[i], i);
+    const E = Array.from({ length: this.stores.length }, () => []), b = new Array(this.stores.length).fill(1);
+    for (let i = 0; i < this.stores.length; i++) {
+      if (this.getLayerAlpha(i) <= 0) continue;
+      const c = this.unsettledTail(t, i), a = c.length;
+      if (a === 0) continue;
+      let S = !0;
+      for (let F = 0; F < a; F++)
+        if (I.get(c[F].time) !== o.length - a + F) {
+          S = !1;
+          break;
+        }
+      if (!S) continue;
+      const p = this.stores[i].getAll(), x = p.length - 1 - a;
+      x < 0 || I.get(p[x].time) === o.length - a - 1 && (E[i] = c.map((F) => J(F.progress)), b[i] = c[a - 1].progress);
+    }
+    const W = (i, c) => {
+      const a = c.length;
+      if (!(a === 0 || i.length < a + 1))
+        for (let S = 0; S < a; S++) {
+          const p = i.length - a + S, x = i[p - 1], F = i[p];
+          i[p] = [U(x[0], F[0], c[S]), U(x[1], F[1], c[S])];
+        }
+    }, Y = s.bitmapSize.height;
+    let N = -1, T = -1;
+    for (let i = 0; i < this.stores.length; i++)
+      if (!(this.getLayerAlpha(i) <= 0))
+        if (N < 0)
+          N = i;
+        else {
+          T = i;
+          break;
+        }
+    const z = N >= 0 ? this.getLayerAlpha(N) : 1;
+    for (let i = this.stores.length - 1; i >= 0; i--) {
+      const c = this.getLayerAlpha(i);
+      if (c <= 0) continue;
+      const a = this.stores[i].last()?.value ?? 0, S = this.resolveLayerColor(i, a), p = E[i];
+      let x = -1;
+      for (let R = i - 1; R >= 0; R--)
+        if (this.getLayerAlpha(R) > 0) {
+          x = R;
+          break;
+        }
+      const F = x >= 0 ? E[x] : [], _ = i === N, H = T >= 0 && i === T && z < 1, X = [];
+      for (let R = 0; R < o.length; R++) {
+        const V = i > 0 ? n.valueToBitmapY(y[i - 1][R]) : Y;
+        let G = V;
+        _ ? G = Y : H && (G = V + (Y - V) * (1 - z)), X.push([r.timeToBitmapX(o[R]), G]);
+      }
+      g === "grow" && W(X, F);
+      const u = [];
+      for (let R = 0; R < o.length; R++) {
+        let V = n.valueToBitmapY(y[i][R]);
+        _ && c < 1 && (V = Y + (V - Y) * c), u.push([r.timeToBitmapX(o[R]), V]);
+      }
+      g === "grow" && W(u, p);
+      const w = $(u), A = Q(w, f, g === "grow" && p.length > 0), O = g === "fade" && b[i] < 1;
+      if (O && (l.save(), l.globalAlpha = b[i]), this.options.area.visible) {
+        let R = u[0][1], V = X[0][1];
+        for (let M = 1; M < u.length; M++)
+          u[M][1] < R && (R = u[M][1]);
+        for (let M = 1; M < X.length; M++)
+          X[M][1] > V && (V = X[M][1]);
+        let G = D(S, 0.25);
+        if (V > R + 0.5) {
+          const M = l.createLinearGradient(0, R, 0, V);
+          M.addColorStop(0, D(S, 0.25)), M.addColorStop(1, D(S, 0.05)), G = M;
+        }
+        if (l.beginPath(), l.moveTo(w[0].x, w[0].y), tt(l, A), _)
+          for (let M = X.length - 1; M >= 0; M--)
+            l.lineTo(X[M][0], X[M][1]);
+        else {
+          const M = $(X), st = Q(M, f, g === "grow" && F.length > 0), q = M[M.length - 1];
+          l.lineTo(q.x, q.y), at(l, M, st);
+        }
+        l.closePath(), l.fillStyle = G, l.fill();
+      }
+      const j = k && c < 1;
+      j && (l.save(), l.globalAlpha *= c), k && (l.beginPath(), l.moveTo(w[0].x, w[0].y), tt(l, A), l.strokeStyle = S, l.lineWidth = B, l.lineJoin = "round", l.lineCap = "round", l.stroke()), j && l.restore(), O && l.restore();
+    }
+  }
+  /**
+   * Overlay hook: draws crosshair nearest-point dots and last-point pulse dots.
+   * Chart invokes this during the overlay pass for any renderer that implements it.
+   */
+  drawOverlay(t) {
+    this.tickAnimations(performance.now());
+    const { scope: e, timeScale: s, yScale: r, crosshair: n, dataInterval: l } = t, d = e, L = this.options.pulseMs, k = L > 0 ? performance.now() / (L * 2 * Math.PI) % 1 : 0;
+    if (n) {
+      const B = this.options.stacking, f = 4 * d.horizontalPixelRatio, m = [], h = [];
+      for (let o = 0; o < this.stores.length; o++) {
+        const C = this.stores[o].findNearest(n.time, l);
+        C ? (m.push(C.value), h.push(C.time)) : (m.push(0), h.push(null));
+      }
+      const P = [];
+      if (B === "off")
+        for (const o of m) P.push(o);
+      else {
+        let o = 0;
+        if (B === "percent")
+          for (let y = 0; y < m.length; y++)
+            o += m[y] * this.getLayerAlpha(y);
+        let C = 0;
+        for (let y = 0; y < m.length; y++) {
+          const g = m[y] * this.getLayerAlpha(y);
+          C += B === "percent" && o > 0 ? g / o * 100 : g, P.push(C);
+        }
+      }
+      for (let o = 0; o < this.stores.length; o++) {
+        const C = h[o];
+        if (C === null) continue;
+        const y = this.getLayerAlpha(o);
+        if (y <= 0) continue;
+        const g = this.resolveLayerColor(o, m[o]), I = s.timeToBitmapX(C), E = r.valueToBitmapY(P[o]), b = y < 1;
+        b && (e.context.save(), e.context.globalAlpha *= y), e.context.save(), e.context.globalAlpha *= 0.25, e.context.beginPath(), e.context.arc(I, E, f + 3 * d.horizontalPixelRatio, 0, Math.PI * 2), e.context.fillStyle = g, e.context.fill(), e.context.restore(), e.context.beginPath(), e.context.arc(I, E, f, 0, Math.PI * 2), e.context.fillStyle = g, e.context.fill(), b && e.context.restore();
+      }
+    }
+    if (this.hasPulse && L > 0) {
+      const B = this.options.stacking;
+      for (let f = 0; f < this.stores.length; f++) {
+        const m = this.getLayerAlpha(f);
+        if (m <= 0) continue;
+        const h = this.stores[f].last()?.value ?? 0, P = this.resolveLayerColor(f, h);
+        if (B === "off") {
+          const b = this.trailingEndpoint(t, f);
+          if (!b) continue;
+          this.drawPulse({
+            ctx: e.context,
+            x: b.x,
+            y: b.y,
+            color: P,
+            pixelRatio: d.horizontalPixelRatio,
+            phase: k,
+            alpha: m
+          });
+          continue;
+        }
+        const o = this.stores[f].last();
+        if (!o) continue;
+        const C = o.time, y = B === "percent", g = (b) => {
+          const W = (T) => {
+            const z = this.getLayerAlpha(T);
+            if (z <= 0) return 0;
+            const i = T === f && b === C ? o : this.stores[T].findNearest(b, 0);
+            return !i || i.time !== b ? 0 : this.effectiveValue(t, T, b, i.value) * z;
+          };
+          let Y = 0;
+          if (y)
+            for (let T = 0; T < this.stores.length; T++)
+              Y += W(T);
+          let N = 0;
+          for (let T = 0; T <= f; T++) {
+            const z = W(T);
+            N += y && Y > 0 ? z / Y * 100 : z;
+          }
+          return N;
+        };
+        let I = s.timeToBitmapX(C), E = r.valueToBitmapY(g(C));
+        if ((this.options.entryAnimation ?? "grow") === "grow") {
+          const b = this.unsettledTail(t, f), W = this.stores[f].getAll(), Y = W.length - 1 - b.length;
+          if (b.length > 0 && Y >= 0) {
+            const N = W[Y];
+            let T = s.timeToBitmapX(N.time), z = r.valueToBitmapY(g(N.time));
+            for (let i = 0; i < b.length; i++) {
+              const c = W[Y + 1 + i], a = J(b[i].progress), S = s.timeToBitmapX(c.time), p = r.valueToBitmapY(g(c.time));
+              T = U(T, S, a), z = U(z, p, a);
+            }
+            I = T, E = z;
+          }
+        }
+        this.drawPulse({
+          ctx: e.context,
+          x: I,
+          y: E,
+          color: P,
+          pixelRatio: d.horizontalPixelRatio,
+          phase: k,
+          alpha: m
+        });
+      }
+    }
+  }
+  drawPulse({
+    ctx: t,
+    x: e,
+    y: s,
+    color: r,
+    pixelRatio: n,
+    phase: l,
+    alpha: d = 1
+  }) {
+    const L = 3 * n, k = 0.4 + 0.6 * Math.abs(Math.sin(l * 2 * Math.PI)), B = L + 4 * n * k, f = d < 1;
+    f && (t.save(), t.globalAlpha *= d), t.beginPath(), t.arc(e, s, B, 0, Math.PI * 2), t.fillStyle = D(r, k * 0.3), t.fill(), t.beginPath(), t.arc(e, s, L, 0, Math.PI * 2), t.fillStyle = r, t.fill(), f && t.restore();
+  }
+}
+const xt = {
+  type: "line",
+  create: ({ theme: v, layerCount: t }, e) => new ht(t, {
+    colors: t === 1 ? [v.line.color] : v.seriesColors.slice(0, t),
+    strokeWidth: v.line.width,
+    ...e
+  })
+};
+export {
+  ht as LineRenderer,
+  xt as LineSeriesDef
+};

package/dist/core/dist/series/painters/builtins.js

@@ -0,0 +1,36 @@
+import { hexToRgba as h } from "../../utils/color.js";
+import { fillRoundedRect as d, tracePath as n } from "./canvas-path.js";
+const p = 0.25, u = (e, t) => {
+  n(e, { points: t.points, kind: "straight", settledOnly: !1 });
+}, x = (e, t) => {
+  n(e, { points: t.points, kind: "stepped", settledOnly: !1 });
+}, y = (e, t) => {
+  n(e, { points: t.points, kind: "smooth", settledOnly: t.grew });
+}, f = (e, t) => {
+  const { ctx: i } = e, { geom: s, color: o, corners: r, radius: l, isProjected: a } = t;
+  i.fillStyle = a ? h(o, p) : o, d(i, {
+    x: s.x,
+    y: s.y,
+    width: s.width,
+    height: s.height,
+    radius: l,
+    corners: r
+  });
+}, m = (e, t) => {
+  const { ctx: i } = e, { geom: s, fillStyle: o, corners: r, radius: l } = t;
+  i.fillStyle = o, d(i, {
+    x: s.x,
+    y: s.y,
+    width: s.width,
+    height: s.height,
+    radius: l,
+    corners: r
+  });
+};
+export {
+  f as roundedBarFill,
+  m as roundedCandleFill,
+  y as smoothCurve,
+  x as steppedCurve,
+  u as straightCurve
+};

package/dist/core/dist/series/painters/canvas-path.js

@@ -0,0 +1,79 @@
+function p(t, u) {
+  const { x: o, y: i, width: r, height: c, corners: e } = u, n = Math.min(u.radius, r / 2, c / 2);
+  if (!(e.tl || e.tr || e.br || e.bl) || n < 1 || r <= 0 || c <= 0) {
+    t.fillRect(o, i, r, c);
+    return;
+  }
+  const s = e.tl ? n : 0, x = e.tr ? n : 0, l = e.br ? n : 0, y = e.bl ? n : 0, f = o + r, h = i + c;
+  t.beginPath(), t.moveTo(o + s, i), t.lineTo(f - x, i), x > 0 && t.arcTo(f, i, f, i + x, x), t.lineTo(f, h - l), l > 0 && t.arcTo(f, h, f - l, h, l), t.lineTo(o + y, h), y > 0 && t.arcTo(o, h, o, h - y, y), t.lineTo(o, i + s), s > 0 && t.arcTo(o, i, o + s, i, s), t.closePath(), t.fill();
+}
+function a(t, u, o) {
+  const i = [];
+  if (t.length < 2) return i;
+  if (u === "stepped") {
+    for (let r = 1; r < t.length; r++)
+      i.push({ kind: "line", x: t[r].x, y: t[r - 1].y }), i.push({ kind: "line", x: t[r].x, y: t[r].y });
+    return i;
+  }
+  if (u === "straight" || t.length === 2) {
+    for (let r = 1; r < t.length; r++)
+      i.push({ kind: "line", x: t[r].x, y: t[r].y });
+    return i;
+  }
+  return b(t, o);
+}
+function d(t, u) {
+  const { ctx: o } = t, { points: i } = u;
+  if (i.length === 0) return;
+  o.moveTo(i[0].x, i[0].y);
+  const r = a(i, u.kind, u.settledOnly);
+  for (const c of r)
+    c.kind === "line" ? o.lineTo(c.x, c.y) : o.bezierCurveTo(c.cp1x, c.cp1y, c.cp2x, c.cp2y, c.x, c.y);
+}
+function b(t, u) {
+  const o = t.length, i = new Array(o - 1);
+  for (let e = 0; e < o - 1; e++) {
+    const n = t[e + 1].x - t[e].x;
+    i[e] = n > 0 ? (t[e + 1].y - t[e].y) / n : Number.NaN;
+  }
+  const r = new Array(o);
+  r[0] = Number.isFinite(i[0]) ? i[0] : 0;
+  for (let e = 1; e < o - 1; e++) {
+    const n = i[e - 1], s = i[e];
+    !Number.isFinite(n) || !Number.isFinite(s) ? r[e] = Number.isFinite(n) ? n : Number.isFinite(s) ? s : 0 : n * s <= 0 ? r[e] = 0 : r[e] = (n + s) / 2;
+  }
+  r[o - 1] = Number.isFinite(i[o - 2]) ? i[o - 2] : 0;
+  for (let e = 0; e < o - 1; e++) {
+    const n = i[e];
+    if (!Number.isFinite(n) || n === 0) continue;
+    const s = r[e] / n, x = r[e + 1] / n, l = s * s + x * x;
+    if (l > 9) {
+      const y = 3 / Math.sqrt(l);
+      r[e] = y * s * n, r[e + 1] = y * x * n;
+    }
+  }
+  const c = [];
+  for (let e = 0; e < o - 1; e++) {
+    const n = t[e], s = t[e + 1], x = e === o - 2;
+    if (!Number.isFinite(i[e]) || u && x) {
+      c.push({ kind: "line", x: s.x, y: s.y });
+      continue;
+    }
+    const l = s.x - n.x;
+    c.push({
+      kind: "bezier",
+      cp1x: n.x + l / 3,
+      cp1y: n.y + r[e] * l / 3,
+      cp2x: s.x - l / 3,
+      cp2y: s.y - r[e + 1] * l / 3,
+      x: s.x,
+      y: s.y
+    });
+  }
+  return c;
+}
+export {
+  a as buildCurveSegments,
+  p as fillRoundedRect,
+  d as tracePath
+};

package/dist/core/dist/series/painters/resolve.js

@@ -0,0 +1,32 @@
+import { roundedCandleFill as i, steppedCurve as f, smoothCurve as d, straightCurve as n, roundedBarFill as u } from "./builtins.js";
+const h = {
+  straight: n,
+  smooth: d,
+  stepped: f
+}, l = /* @__PURE__ */ new WeakSet();
+function p(e, t, r) {
+  l.has(t) || (l.add(t), console.warn(`[wick-charts] a ${e} painter threw; falling back to the default for this series.`, r));
+}
+function a(e, t, r) {
+  return (o, s) => {
+    try {
+      t(o, s);
+    } catch (c) {
+      p(e, t, c), r(o, s);
+    }
+  };
+}
+function m(e) {
+  return e ? a("bar", e, u) : u;
+}
+function v(e) {
+  return e ? a("candle", e, i) : i;
+}
+function C(e) {
+  return typeof e == "function" ? a("line", e, n) : typeof e == "string" ? h[e] ?? n : n;
+}
+export {
+  m as resolveBarPainter,
+  v as resolveCandlePainter,
+  C as resolveLinePainter
+};