@wick-charts/vue 0.4.2 → 0.5.0

package/README.md

@@ -59,13 +59,15 @@ Start there for [ChartContainer](https://wick-charts.eeff.io/api/chart-container
 
 ## Bundle size
 
+Packages ship per-module ESM with `sideEffects: false`, and each series component carries its own renderer — your bundler only ships the chart types you import.
+
 Tree-shaken React scenarios via `pnpm size` (esbuild, minified, browser target, React/ReactDOM external):
 
 | Scenario | Raw | Gzip | Brotli |
 |---|---:|---:|---:|
-| Candlestick only | 174.1 kB | 52.4 kB | 44.8 kB |
-| Line only        | 174.1 kB | 52.5 kB | 44.8 kB |
-| Full React       | 191.2 kB | 57.4 kB | 49.0 kB |
+| Candlestick only | 83.3 kB  | 25.9 kB | 22.9 kB |
+| Line only        | 91.3 kB  | 28.3 kB | 25.0 kB |
+| Full React       | 180.3 kB | 55.5 kB | 47.1 kB |
 
 ## Migration
 

package/dist/BarSeries.vue.js

@@ -0,0 +1,44 @@
+import { defineComponent as p, ref as d, onMounted as c, onUnmounted as l, watch as i, createCommentVNode as m } from "vue";
+import { toLayers as f, EMPTY_SYNC_STATE as v, syncLayers as y } from "./core/dist/data/sync.js";
+import { BarSeriesDef as S } from "./core/dist/series/bar.js";
+import { useChartInstance as _ } from "./context.js";
+const w = /* @__PURE__ */ p({
+  __name: "BarSeries",
+  props: {
+    data: {},
+    options: {},
+    id: {}
+  },
+  setup(u) {
+    const a = u, o = _(), r = d(null);
+    let n = [];
+    function s(e, t) {
+      n = y({ chart: o, id: e, data: t, prev: n });
+    }
+    return c(() => {
+      const e = f(a.data).length, t = o.addSeries(S, {
+        ...a.options,
+        layers: e,
+        id: a.id
+      });
+      r.value = t, n = new Array(e).fill(v), s(t, a.data);
+    }), l(() => {
+      r.value && o.removeSeries(r.value);
+    }), i(
+      () => a.data,
+      (e) => {
+        const t = r.value;
+        t && s(t, e);
+      }
+    ), i(
+      () => a.options,
+      (e) => {
+        r.value && e && o.updateSeriesOptions(r.value, e);
+      },
+      { deep: !0 }
+    ), (e, t) => m("", !0);
+  }
+});
+export {
+  w as default
+};

package/dist/BarSeries.vue2.js

@@ -0,0 +1,4 @@
+import f from "./BarSeries.vue.js";
+export {
+  f as default
+};

package/dist/CandlestickSeries.vue.js

@@ -0,0 +1,45 @@
+import { defineComponent as p, ref as u, onMounted as m, onUnmounted as f, watch as d, createCommentVNode as S } from "vue";
+import { toLayers as l, syncSeriesLayer as v, EMPTY_SYNC_STATE as _ } from "./core/dist/data/sync.js";
+import { CandlestickSeriesDef as y } from "./core/dist/series/candlestick.js";
+import { useChartInstance as C } from "./context.js";
+const k = /* @__PURE__ */ p({
+  __name: "CandlestickSeries",
+  props: {
+    data: {},
+    options: {},
+    id: {}
+  },
+  setup(c) {
+    const t = c, r = C(), a = u(null);
+    let o = _;
+    function n(e, s) {
+      const i = l(s)[0];
+      r.setSeriesLabels(e, [i.label]), o = v({ chart: r, id: e, data: i.data, prev: o });
+    }
+    return m(() => {
+      const e = r.addSeries(y, {
+        ...t.options,
+        id: t.id,
+        label: l(t.data)[0].label
+      });
+      a.value = e, n(e, t.data);
+    }), f(() => {
+      a.value && r.removeSeries(a.value);
+    }), d(
+      () => t.data,
+      (e) => {
+        const s = a.value;
+        s && n(s, e);
+      }
+    ), d(
+      () => t.options,
+      (e) => {
+        a.value && e && r.updateSeriesOptions(a.value, e);
+      },
+      { deep: !0 }
+    ), (e, s) => S("", !0);
+  }
+});
+export {
+  k as default
+};

package/dist/CandlestickSeries.vue2.js

@@ -0,0 +1,4 @@
+import f from "./CandlestickSeries.vue.js";
+export {
+  f as default
+};

package/dist/ChartContainer.vue.js

@@ -0,0 +1,168 @@
+import { defineComponent as N, ref as a, shallowRef as C, provide as r, computed as K, onMounted as T, nextTick as b, onUnmounted as j, watch as l, openBlock as u, createElementBlock as v, normalizeStyle as M, createElementVNode as o, createCommentVNode as k, renderSlot as S } from "vue";
+import { ChartInstance as O } from "./core/dist/chart.js";
+import { catppuccin as G } from "./core/dist/theme/themes/catppuccin.js";
+import { ChartKey as H, ThemeKey as I, TitleAnchorKey as P, InfoBarAnchorKey as V, LegendAnchorKey as U, LegendRightAnchorKey as q, NavigatorAnchorKey as D } from "./context.js";
+const F = { style: { display: "flex", "flex-direction": "row", flex: "1", "min-height": "0" } }, J = { style: { display: "flex", "flex-direction": "column", flex: "1", "min-width": "0", "min-height": "0" } }, Q = {
+  key: 0,
+  "data-chart-header": "",
+  style: { "flex-shrink": "0", display: "flex", "flex-direction": "column", "pointer-events": "none" }
+}, W = {
+  key: 1,
+  "data-chart-series-overlay": "",
+  style: { position: "absolute", inset: "0", "pointer-events": "none", "z-index": "3" }
+}, ne = /* @__PURE__ */ N({
+  __name: "ChartContainer",
+  props: {
+    theme: { default: () => G.theme },
+    axis: {},
+    padding: {},
+    viewport: {},
+    gradient: { type: Boolean, default: !0 },
+    interactive: { type: Boolean },
+    grid: {},
+    headerLayout: { default: "overlay" },
+    animations: { type: [Boolean, Object] },
+    perf: {},
+    onEdgeReached: {}
+  },
+  setup(h) {
+    const e = h, c = a(), i = C(null), p = C(e.theme), s = e.perf, f = e.onEdgeReached, A = a(null), g = a(null), y = a(null), w = a(null), _ = a(null), R = a(null);
+    r(H, i), r(I, p), r(P, g), r(V, y), r(U, w), r(q, _), r(D, R);
+    let d = null;
+    const m = a(0), B = K(() => e.headerLayout === "overlay" ? m.value : 0);
+    function x() {
+      if (!i.value) return;
+      const n = { top: (e.padding?.top ?? 20) + B.value };
+      e.padding?.bottom !== void 0 && (n.bottom = e.padding.bottom), e.padding?.right !== void 0 && (n.right = e.padding.right), e.padding?.left !== void 0 && (n.left = e.padding.left), i.value.setPadding(n);
+    }
+    function E() {
+      d?.disconnect(), d = null;
+      const t = e.headerLayout === "overlay" ? A.value : null;
+      if (!t) {
+        m.value = 0, x();
+        return;
+      }
+      const n = () => {
+        m.value = t.getBoundingClientRect().height, x();
+      };
+      n(), d = new ResizeObserver(n), d.observe(t);
+    }
+    T(async () => {
+      if (!c.value) return;
+      const t = {};
+      e.axis && (t.axis = e.axis), e.theme && (t.theme = e.theme), e.padding && (t.padding = e.padding), e.viewport && (t.viewport = e.viewport), e.interactive !== void 0 && (t.interactive = e.interactive), e.grid !== void 0 && (t.grid = e.grid), s !== void 0 && (t.perf = s), f && (t.onEdgeReached = f), e.animations !== void 0 && (t.animations = e.animations), i.value = new O(c.value, t), await b(), E();
+    }), j(() => {
+      d?.disconnect(), d = null, i.value?.destroy(), i.value = null;
+    }), l(
+      () => e.headerLayout,
+      async () => {
+        i.value && (await b(), E());
+      }
+    ), l(
+      () => e.theme,
+      (t) => {
+        i.value && t && (i.value.setTheme(t), p.value = t);
+      }
+    ), l(
+      () => e.axis,
+      (t) => {
+        i.value && t && i.value.setAxis(t);
+      },
+      { deep: !0 }
+    ), l(
+      () => e.grid?.visible,
+      () => {
+        i.value && e.grid !== void 0 && i.value.setGrid(e.grid);
+      }
+    ), l(
+      () => e.animations,
+      async (t) => {
+        if (!i.value || !c.value) return;
+        i.value.destroy(), i.value = null, await b();
+        const n = {};
+        e.axis && (n.axis = e.axis), e.theme && (n.theme = e.theme), e.padding && (n.padding = e.padding), e.viewport && (n.viewport = e.viewport), e.interactive !== void 0 && (n.interactive = e.interactive), e.grid !== void 0 && (n.grid = e.grid), s !== void 0 && (n.perf = s), f && (n.onEdgeReached = f), t !== void 0 && (n.animations = t), i.value = new O(c.value, n);
+      }
+    ), l(
+      () => [
+        e.padding?.top,
+        e.padding?.bottom,
+        typeof e.padding?.right == "object" ? e.padding.right.intervals : e.padding?.right,
+        typeof e.padding?.left == "object" ? e.padding.left.intervals : e.padding?.left,
+        B.value
+      ],
+      x
+    );
+    const z = K(() => {
+      const t = p.value, [n, $] = t?.chartGradient ?? ["transparent", "transparent"], L = t?.background ?? "transparent";
+      return `position: relative; display: flex; flex-direction: column; width: 100%; height: 100%; overflow: hidden; background: ${e.gradient ? `linear-gradient(to bottom, ${n} 0%, ${L} 70%, ${$} 100%)` : L}`;
+    });
+    return (t, n) => (u(), v("div", {
+      style: M(z.value)
+    }, [
+      o("div", F, [
+        o("div", J, [
+          h.headerLayout === "inline" ? (u(), v("div", Q, [
+            o("div", {
+              ref_key: "titleAnchor",
+              ref: g,
+              "data-chart-title-anchor": ""
+            }, null, 512),
+            o("div", {
+              ref_key: "infoBarAnchor",
+              ref: y,
+              "data-tooltip-legend-anchor": ""
+            }, null, 512)
+          ])) : k("", !0),
+          o("div", {
+            ref_key: "containerRef",
+            ref: c,
+            style: { position: "relative", flex: "1", "min-width": "0", "min-height": "0", overflow: "hidden" }
+          }, [
+            h.headerLayout === "overlay" ? (u(), v("div", {
+              key: 0,
+              ref_key: "topOverlayRef",
+              ref: A,
+              "data-chart-top-overlay": "",
+              style: { position: "absolute", top: "0", left: "0", right: "0", "z-index": "2", "pointer-events": "none", display: "flex", "flex-direction": "column" }
+            }, [
+              o("div", {
+                ref_key: "titleAnchor",
+                ref: g,
+                "data-chart-title-anchor": ""
+              }, null, 512),
+              o("div", {
+                ref_key: "infoBarAnchor",
+                ref: y,
+                "data-tooltip-legend-anchor": ""
+              }, null, 512)
+            ], 512)) : k("", !0),
+            i.value ? (u(), v("div", W, [
+              S(t.$slots, "default")
+            ])) : k("", !0)
+          ], 512)
+        ]),
+        o("div", {
+          ref_key: "legendRightAnchor",
+          ref: _,
+          "data-legend-right-anchor": "",
+          style: { flex: "0 0 auto" }
+        }, null, 512)
+      ]),
+      o("div", {
+        ref_key: "legendAnchor",
+        ref: w,
+        "data-legend-anchor": "",
+        style: { flex: "0 0 auto" }
+      }, null, 512),
+      o("div", {
+        ref_key: "navigatorAnchor",
+        ref: R,
+        "data-navigator-anchor": "",
+        style: { flex: "0 0 auto" }
+      }, null, 512)
+    ], 4));
+  }
+});
+export {
+  ne as default
+};

package/dist/ChartContainer.vue2.js

@@ -0,0 +1,4 @@
+import f from "./ChartContainer.vue.js";
+export {
+  f as default
+};

package/dist/LineSeries.vue.js

@@ -0,0 +1,44 @@
+import { defineComponent as p, ref as d, onMounted as c, onUnmounted as l, watch as i, createCommentVNode as m } from "vue";
+import { toLayers as f, EMPTY_SYNC_STATE as v, syncLayers as y } from "./core/dist/data/sync.js";
+import { LineSeriesDef as S } from "./core/dist/series/line.js";
+import { useChartInstance as _ } from "./context.js";
+const A = /* @__PURE__ */ p({
+  __name: "LineSeries",
+  props: {
+    data: {},
+    options: {},
+    id: {}
+  },
+  setup(u) {
+    const a = u, n = _(), r = d(null);
+    let o = [];
+    function s(e, t) {
+      o = y({ chart: n, id: e, data: t, prev: o });
+    }
+    return c(() => {
+      const e = f(a.data).length, t = n.addSeries(S, {
+        ...a.options,
+        layers: e,
+        id: a.id
+      });
+      r.value = t, o = new Array(e).fill(v), s(t, a.data);
+    }), l(() => {
+      r.value && n.removeSeries(r.value);
+    }), i(
+      () => a.data,
+      (e) => {
+        const t = r.value;
+        t && s(t, e);
+      }
+    ), i(
+      () => a.options,
+      (e) => {
+        r.value && e && n.updateSeriesOptions(r.value, e);
+      },
+      { deep: !0 }
+    ), (e, t) => m("", !0);
+  }
+});
+export {
+  A as default
+};

package/dist/LineSeries.vue2.js

@@ -0,0 +1,4 @@
+import f from "./LineSeries.vue.js";
+export {
+  f as default
+};

package/dist/PieSeries.vue.js

@@ -0,0 +1,34 @@
+import { defineComponent as i, ref as n, onMounted as u, onUnmounted as d, watch as r, createCommentVNode as p } from "vue";
+import { PieSeriesDef as m } from "./core/dist/series/pie.js";
+import { useChartInstance as c } from "./context.js";
+const h = /* @__PURE__ */ i({
+  __name: "PieSeries",
+  props: {
+    data: {},
+    options: {},
+    id: {}
+  },
+  setup(s) {
+    const a = s, o = c(), t = n(null);
+    return u(() => {
+      const e = o.addSeries(m, { ...a.options, id: a.id });
+      t.value = e, a.data.length > 0 && o.setSeriesData(e, a.data);
+    }), d(() => {
+      t.value && o.removeSeries(t.value);
+    }), r(
+      () => a.data,
+      (e) => {
+        t.value && e.length > 0 && o.setSeriesData(t.value, e);
+      }
+    ), r(
+      () => a.options,
+      (e) => {
+        t.value && e && o.updateSeriesOptions(t.value, e);
+      },
+      { deep: !0 }
+    ), (e, f) => p("", !0);
+  }
+});
+export {
+  h as default
+};

package/dist/PieSeries.vue2.js

@@ -0,0 +1,4 @@
+import f from "./PieSeries.vue.js";
+export {
+  f as default
+};

package/dist/composables.js

@@ -0,0 +1,44 @@
+import { ref as a, onMounted as u, onUnmounted as i } from "vue";
+function f(e) {
+  const o = a(e.getVisibleRange()), n = () => {
+    o.value = e.getVisibleRange();
+  };
+  return u(() => e.on("viewportChange", n)), i(() => e.off("viewportChange", n)), o;
+}
+function p(e) {
+  const o = a(e.getYRange()), n = () => {
+    o.value = e.getYRange();
+  };
+  return u(() => e.on("viewportChange", n)), i(() => e.off("viewportChange", n)), o;
+}
+function d(e, o) {
+  let n = e.getLastValue(o), t = n ? e.yScale.valueToY(n.value) : null;
+  const v = a(n), l = () => {
+    const s = e.getLastValue(o), g = s ? e.yScale.valueToY(s.value) : null;
+    n?.value === s?.value && n?.isLive === s?.isLive && t === g || (n = s, t = g, v.value = s);
+  };
+  return u(() => {
+    e.on("dataUpdate", l), e.on("viewportChange", l);
+  }), i(() => {
+    e.off("dataUpdate", l), e.off("viewportChange", l);
+  }), v;
+}
+function C(e, o) {
+  const n = a(e.getPreviousClose(o)), t = () => {
+    n.value = e.getPreviousClose(o);
+  };
+  return u(() => e.on("dataUpdate", t)), i(() => e.off("dataUpdate", t)), n;
+}
+function Y(e) {
+  const o = a(e.getCrosshairPosition()), n = () => {
+    o.value = e.getCrosshairPosition();
+  };
+  return u(() => e.on("crosshairMove", n)), i(() => e.off("crosshairMove", n)), o;
+}
+export {
+  Y as useCrosshairPosition,
+  d as useLastYValue,
+  C as usePreviousClose,
+  f as useVisibleRange,
+  p as useYRange
+};

package/dist/context.js

@@ -0,0 +1,25 @@
+import { inject as n } from "vue";
+const t = Symbol("wick-chart"), o = Symbol("wick-theme"), c = Symbol("wick-title-anchor"), h = Symbol("wick-info-bar-anchor"), i = Symbol("wick-legend-anchor"), a = Symbol("wick-legend-right-anchor"), s = Symbol("wick-navigator-anchor");
+function m() {
+  const e = n(t);
+  if (!e || !e.value)
+    throw new Error("useChartInstance must be used within <ChartContainer>");
+  return e.value;
+}
+function u() {
+  const e = n(o);
+  if (!e)
+    throw new Error("useTheme must be used within <ChartContainer>");
+  return e;
+}
+export {
+  t as ChartKey,
+  h as InfoBarAnchorKey,
+  i as LegendAnchorKey,
+  a as LegendRightAnchorKey,
+  s as NavigatorAnchorKey,
+  o as ThemeKey,
+  c as TitleAnchorKey,
+  m as useChartInstance,
+  u as useTheme
+};

package/dist/core/dist/animation/animator.js

@@ -0,0 +1,72 @@
+import { easeOutCubic as r } from "./easing.js";
+class a {
+  #t;
+  #h;
+  #i;
+  #u = 0;
+  #r;
+  #e;
+  #o;
+  #n;
+  #c;
+  #a;
+  #s = !1;
+  constructor(t) {
+    this.#t = t.initial, this.#h = t.initial, this.#i = t.initial, this.#o = t.duration, this.#r = t.duration, this.#n = t.easing ?? r, this.#e = this.#n, this.#c = t.lerp, this.#a = t.equals ?? Object.is;
+  }
+  get current() {
+    return this.#t;
+  }
+  get target() {
+    return this.#i;
+  }
+  get animating() {
+    return this.#s;
+  }
+  /** Replace the target instantly; cancels any in-flight animation. */
+  snap(t) {
+    this.#t = t, this.#h = t, this.#i = t, this.#s = !1;
+  }
+  /**
+   * Set a new target. If `opts.duration` is omitted, the animator's default
+   * is used. `duration <= 0` is equivalent to {@link snap}.
+   *
+   * Pass `opts.now` to make the animation's start time agree with the host's
+   * render loop or event timestamp; defaults to `performance.now()`. This
+   * matters when the caller already has a frame timestamp in hand — without
+   * it, `setTarget` and the next `tick(rafNow)` would disagree by however many
+   * milliseconds passed between the call and the RAF callback firing.
+   *
+   * Mid-flight retarget preserves visual continuity: the animator first
+   * advances `current` to its position at the supplied `now`, then assigns
+   * that as the new `from` and starts a fresh ease toward `value`. Because
+   * `from` is the actual current position, the cubic ease resumes seamlessly
+   * even though the curve technically restarts.
+   */
+  setTarget(t, i = {}) {
+    const s = i.now ?? performance.now();
+    if (this.#s) {
+      if (this.#a(t, this.#i)) return;
+      this.tick(s);
+    } else if (this.#a(t, this.#t))
+      return;
+    const h = i.duration ?? this.#o;
+    if (h <= 0) {
+      this.snap(t);
+      return;
+    }
+    this.#h = this.#t, this.#i = t, this.#r = h, this.#e = i.easing ?? this.#n, this.#u = s, this.#s = !0;
+  }
+  /** Advance `current` toward `target`. Returns `true` while still animating. */
+  tick(t) {
+    if (!this.#s) return !1;
+    const i = t - this.#u;
+    if (i >= this.#r)
+      return this.#t = this.#i, this.#s = !1, !1;
+    const s = i <= 0 ? 0 : i / this.#r;
+    return this.#t = this.#c(this.#h, this.#i, this.#e(s)), !0;
+  }
+}
+export {
+  a as Animator
+};

package/dist/core/dist/animation/config.js

@@ -0,0 +1,145 @@
+import { spring as k } from "./spring.js";
+import { resolveAnimationTime as t } from "./time.js";
+import { hermite as F } from "./y-range-hermite.js";
+import { snap as l } from "./y-range-snap.js";
+const E = 250, _ = 250, S = E, U = _, D = 600, d = E, g = _, v = E, I = _, N = 250, Y = 250, x = 200, C = 150, R = 250, u = 2500, T = 500, O = 100, b = 250, K = 250, m = {
+  line: { entryMs: 0, smoothMs: 0, pulseMs: 0 },
+  candlestick: { entryMs: 0, smoothMs: 0 },
+  bar: { entryMs: 0, smoothMs: 0 },
+  pie: { entryMs: 0, updateMs: 0 }
+};
+function G(i) {
+  if (i !== null && typeof i == "object")
+    return {
+      stickyMs: t(i.max, u),
+      stickyFloorMs: t(i.min, T)
+    };
+  if (i === void 0)
+    return { stickyMs: u, stickyFloorMs: T };
+  const s = t(i, u);
+  return { stickyMs: s, stickyFloorMs: s };
+}
+class y {
+  axis;
+  toggleMs;
+  series;
+  constructor(s, e, o) {
+    this.axis = s, this.toggleMs = e, this.series = o;
+  }
+  /**
+   * Collapse the public `animations` surface into a resolved config.
+   * `animations: false` disables everything; category-level `false`
+   * disables every field in that category; otherwise missing fields
+   * inherit built-in defaults.
+   */
+  static resolve(s) {
+    if (s === !1)
+      return new y(
+        {
+          y: { curve: l(), settleMs: 0, stickyMs: 0, stickyFloorMs: 0, gestureMs: 0 },
+          x: { curve: l(), settleMs: 0, gestureMs: 0 },
+          ticksMs: 0
+        },
+        0,
+        m
+      );
+    const e = s === !0 || s === void 0 ? void 0 : s, o = e?.axis, r = o === !1 ? !1 : o?.y, n = o === !1 ? !1 : o?.x, M = o === !1 ? !1 : o?.ticks, a = e?.toggle, c = e?.series, f = r === !1 ? {
+      curve: l(),
+      settleMs: 0,
+      stickyMs: 0,
+      stickyFloorMs: 0,
+      gestureMs: 0
+    } : {
+      curve: r?.curve ?? F(),
+      settleMs: t(r?.settle, R),
+      ...G(r?.sticky),
+      gestureMs: t(r?.gesture, O)
+    }, h = n === !1 ? {
+      curve: l(),
+      settleMs: 0,
+      gestureMs: 0
+    } : {
+      curve: n?.curve ?? k(),
+      settleMs: t(n?.settle, x),
+      gestureMs: t(n?.gesture, C)
+    }, p = M === !1 ? 0 : t(M, K), L = t(a, b), A = P(c);
+    return new y({ y: f, x: h, ticksMs: p }, L, A);
+  }
+  /**
+   * Per-renderer-type chart-level option payload — merged BEFORE user
+   * series options so explicit per-series options always win. Forwards
+   * the resolved `entryMs` / `smoothMs` / `pulseMs` straight into the
+   * renderer's option shape. `pulseMs` is line-only; bars / candles
+   * ignore it.
+   */
+  defaults(s) {
+    if (s === "line") {
+      const { entryMs: r, smoothMs: n, pulseMs: M } = this.series.line;
+      return { entryMs: r, smoothMs: n, pulseMs: M };
+    }
+    if (s === "candlestick") {
+      const { entryMs: r, smoothMs: n } = this.series.candlestick;
+      return { entryMs: r, smoothMs: n };
+    }
+    if (s === "pie") {
+      const { entryMs: r, updateMs: n } = this.series.pie;
+      return { entryMs: r, updateMs: n };
+    }
+    const { entryMs: e, smoothMs: o } = this.series.bar;
+    return { entryMs: e, smoothMs: o };
+  }
+  /**
+   * Chart-level forced overrides — `animations.series.<type>: false` (or
+   * any category set to `false`) is documented as a hard disable. Merged
+   * AFTER user options so the disable can't be undone at the per-series
+   * layer.
+   */
+  overrides(s) {
+    const e = {};
+    if (s === "line") {
+      const { entryMs: n, smoothMs: M, pulseMs: a } = this.series.line;
+      return n === 0 && (e.entryMs = 0), M === 0 && (e.smoothMs = 0), a === 0 && (e.pulseMs = 0), e;
+    }
+    if (s === "pie") return e;
+    const { entryMs: o, smoothMs: r } = s === "candlestick" ? this.series.candlestick : this.series.bar;
+    return o === 0 && (e.entryMs = 0), r === 0 && (e.smoothMs = 0), e;
+  }
+}
+function P(i) {
+  if (i === !1) return m;
+  const s = i?.line, e = i?.candlestick, o = i?.bar, r = i?.pie, n = s === !1 ? { entryMs: 0, smoothMs: 0, pulseMs: 0 } : {
+    entryMs: t(s?.entry, S),
+    smoothMs: t(s?.smooth, U),
+    pulseMs: t(s?.pulse, D)
+  }, M = e === !1 ? { entryMs: 0, smoothMs: 0 } : {
+    entryMs: t(e?.entry, d),
+    smoothMs: t(e?.smooth, g)
+  }, a = o === !1 ? { entryMs: 0, smoothMs: 0 } : {
+    entryMs: t(o?.entry, v),
+    smoothMs: t(o?.smooth, I)
+  }, c = r === !1 ? { entryMs: 0, updateMs: 0 } : {
+    entryMs: t(r?.entry, N),
+    updateMs: t(r?.update, Y)
+  };
+  return { line: n, candlestick: M, bar: a, pie: c };
+}
+export {
+  y as AnimationConfig,
+  v as DEFAULT_BAR_ENTRY,
+  I as DEFAULT_BAR_SMOOTH,
+  d as DEFAULT_CANDLESTICK_ENTRY,
+  g as DEFAULT_CANDLESTICK_SMOOTH,
+  S as DEFAULT_LINE_ENTRY,
+  D as DEFAULT_LINE_PULSE,
+  U as DEFAULT_LINE_SMOOTH,
+  N as DEFAULT_PIE_ENTRY,
+  Y as DEFAULT_PIE_UPDATE,
+  K as DEFAULT_TICKS_MS,
+  b as DEFAULT_TOGGLE_MS,
+  C as DEFAULT_X_GESTURE_MS,
+  x as DEFAULT_X_SETTLE_MS,
+  O as DEFAULT_Y_GESTURE_MS,
+  R as DEFAULT_Y_SETTLE_MS,
+  u as DEFAULT_Y_STICKY_MAX_MS,
+  T as DEFAULT_Y_STICKY_MIN_MS
+};

package/dist/core/dist/animation/easing.js

@@ -0,0 +1,4 @@
+const e = (t) => 1 - (1 - t) ** 3;
+export {
+  e as easeOutCubic
+};