@wick-charts/vue 0.8.0 → 0.8.2

package/dist/core/dist/snapshots.js

@@ -1,120 +1,143 @@
-import { pointValue as m } from "./utils/point.js";
-const f = /* @__PURE__ */ new WeakMap();
-function y(e, r) {
-  return f.get(e)?.get(r);
+import { isGapPoint as f, pointValue as h } from "./utils/point.js";
+import { formatDate as x } from "./utils/time.js";
+const g = /* @__PURE__ */ new WeakMap();
+function I(e, t) {
+  return g.get(e)?.get(t);
 }
-function I(e, r, n) {
-  let o = f.get(e);
-  o || (o = /* @__PURE__ */ new Map(), f.set(e, o)), o.set(r, n);
+function y(e, t, o) {
+  let n = g.get(e);
+  n || (n = /* @__PURE__ */ new Map(), g.set(e, n)), n.set(t, o);
 }
-function g(e) {
-  const r = e.low !== void 0 && e.high !== void 0 ? { time: e.time, low: e.low, high: e.high } : { time: e.time, value: e.value };
-  return e.x !== void 0 && (r.x = e.x), r;
+function b(e) {
+  const t = e.low !== void 0 && e.high !== void 0 ? { time: e.time, low: e.low, high: e.high } : { time: e.time, value: e.value };
+  return e.x !== void 0 && (t.x = e.x), t;
 }
-function h(e, r) {
-  if (r === "none" || e.length <= 1) return e;
-  const n = [...e];
-  return n.sort((o, a) => {
-    const s = m(o.data), i = m(a.data);
-    return r === "asc" ? s - i : i - s;
-  }), n;
+function S(e, t) {
+  if (t === "none" || e.length <= 1) return e;
+  const o = [...e];
+  return o.sort((n, r) => {
+    const s = h(n.data), c = h(r.data);
+    return t === "asc" ? s - c : c - s;
+  }), o;
 }
-function u(e) {
-  const r = Object.freeze({ ...e.data }), n = {
+function m(e) {
+  const t = Object.freeze({ ...e.data }), o = {
     id: e.id,
     seriesId: e.seriesId,
     layerIndex: e.layerIndex,
     label: e.label,
-    data: r,
-    color: e.color
+    data: t,
+    color: e.color,
+    ...e.share === void 0 ? {} : { share: e.share }
   };
-  return Object.freeze(n);
+  return Object.freeze(o);
 }
-function S(e, r) {
-  const n = r.sort ?? "none", o = e.getOverlayVersion(), a = y(e, r.cacheKey);
-  if (a && a.version === o && a.time === r.time && a.sort === n)
-    return a.data;
+function w(e, t) {
+  const o = t.sort ?? "none", n = e.getSnapshotVersion(), r = I(e, t.cacheKey);
+  if (r && r.version === n && r.time === t.time && r.sort === o)
+    return r.data;
   const s = [];
-  for (const t of e.getSeriesIds()) {
-    if (!e.isSeriesVisible(t)) continue;
-    if (e.getSeriesLayers(t) !== null) {
-      const d = e.getLayerSnapshots(t, r.time);
+  for (const a of e.getSeriesIds()) {
+    if (!e.isSeriesVisible(a)) continue;
+    if (e.getSeriesLayers(a) !== null) {
+      const d = e.getLayerSnapshots(a, t.time);
       if (!d) continue;
-      for (const l of d)
-        s.push(
-          u({
-            id: `${t}_layer${l.layerIndex}`,
-            seriesId: t,
-            layerIndex: l.layerIndex,
-            label: e.getLayerLabel(t, l.layerIndex),
-            data: g(l),
-            color: l.color
+      for (const i of d) {
+        const u = b(i);
+        f(u) || s.push(
+          m({
+            id: `${a}_layer${i.layerIndex}`,
+            seriesId: a,
+            layerIndex: i.layerIndex,
+            label: e.getLayerLabel(a, i.layerIndex),
+            data: u,
+            color: i.color,
+            share: i.share
           })
         );
+      }
       continue;
     }
-    const c = e.getDataAtTime(t, r.time);
-    c && s.push(
-      u({
-        id: t,
-        seriesId: t,
-        label: e.getSeriesLabel(t),
-        data: c,
-        color: e.getSeriesColor(t) ?? "#888"
+    const l = e.getDataAtTime(a, t.time);
+    !l || f(l) || s.push(
+      m({
+        id: a,
+        seriesId: a,
+        label: e.getSeriesLabel(a),
+        data: l,
+        color: e.getSeriesColor(a) ?? "#888"
       })
     );
   }
-  const i = Object.freeze(h(s, n));
-  return I(e, r.cacheKey, { version: o, time: r.time, sort: n, data: i }), i;
+  const c = Object.freeze(S(s, o));
+  return y(e, t.cacheKey, { version: n, time: t.time, sort: o, data: c }), c;
 }
-function p(e, r) {
-  const { time: n, snapshots: o, interval: a } = r;
-  if (e.timeScale.getType() !== "numeric") return e.timeScale.formatX(n, a);
-  let s = n, i = Number.POSITIVE_INFINITY;
-  for (const t of o) {
-    const c = Math.abs(t.data.time - n), d = c === i && t.data.time <= s;
-    c > i || d || (i = c, s = t.data.time);
+const v = 864e5;
+function p(e, t) {
+  let o = e, n = Number.POSITIVE_INFINITY;
+  for (const r of t) {
+    const s = Math.abs(r.data.time - e), c = s === n && r.data.time <= o;
+    s > n || c || (n = s, o = r.data.time);
   }
-  return e.timeScale.formatPointX(s, a);
+  return o;
 }
-function x(e, r) {
-  const n = r.sort ?? "none", o = e.getOverlayVersion(), a = y(e, r.cacheKey);
-  if (a && a.version === o && a.time === null && a.sort === n)
-    return a.data;
+function L(e, t) {
+  const o = p(t.time, t.snapshots);
+  return e.timeScale.formatPointX(o, t.interval);
+}
+function T(e, t) {
+  const o = L(e, t);
+  if (e.timeScale.getType() !== "time") return o;
+  const n = p(t.time, t.snapshots), r = x(n, { locale: e.timeScale.getLocale(), timeZone: e.timeScale.getTimeZone() });
+  return t.interval >= v && e.timeScale.getFormat() === null ? r : `${r} ${o}`;
+}
+function O(e, t) {
+  const o = t(h(e.data));
+  return e.share === void 0 ? o : `${Number(e.share.toFixed(1))}% · ${o}`;
+}
+function j(e, t) {
+  const o = t.sort ?? "none", n = e.getSnapshotVersion(), r = I(e, t.cacheKey);
+  if (r && r.version === n && r.time === null && r.sort === o)
+    return r.data;
   const s = [];
-  for (const t of e.getSeriesIds()) {
-    if (!e.isSeriesVisible(t)) continue;
-    const c = e.getLayerLastSnapshots(t);
-    if (c) {
-      for (const l of c)
-        s.push(
-          u({
-            id: `${t}_layer${l.layerIndex}`,
-            seriesId: t,
-            layerIndex: l.layerIndex,
-            label: e.getLayerLabel(t, l.layerIndex),
-            data: g(l),
-            color: l.color
+  for (const a of e.getSeriesIds()) {
+    if (!e.isSeriesVisible(a)) continue;
+    const l = e.getLayerLastSnapshots(a);
+    if (l) {
+      for (const i of l) {
+        const u = b(i);
+        f(u) || s.push(
+          m({
+            id: `${a}_layer${i.layerIndex}`,
+            seriesId: a,
+            layerIndex: i.layerIndex,
+            label: e.getLayerLabel(a, i.layerIndex),
+            data: u,
+            color: i.color,
+            share: i.share
           })
         );
+      }
       continue;
     }
-    const d = e.getLastData(t);
-    d && s.push(
-      u({
-        id: t,
-        seriesId: t,
-        label: e.getSeriesLabel(t),
+    const d = e.getLastData(a);
+    !d || f(d) || s.push(
+      m({
+        id: a,
+        seriesId: a,
+        label: e.getSeriesLabel(a),
         data: d,
-        color: e.getSeriesColor(t) ?? "#888"
+        color: e.getSeriesColor(a) ?? "#888"
       })
     );
   }
-  const i = Object.freeze(h(s, n));
-  return I(e, r.cacheKey, { version: o, time: null, sort: n, data: i }), i;
+  const c = Object.freeze(S(s, o));
+  return y(e, t.cacheKey, { version: n, time: null, sort: o, data: c }), c;
 }
 export {
-  S as buildHoverSnapshots,
-  x as buildLastSnapshots,
-  p as formatHeaderX
+  w as buildHoverSnapshots,
+  j as buildLastSnapshots,
+  L as formatHeaderX,
+  O as formatRowValue,
+  T as formatTooltipHeader
 };

package/dist/core/dist/utils/point.js

@@ -4,7 +4,11 @@ function i(n) {
 function o(n) {
   return "close" in n ? n.close : i(n) ? (n.low + n.high) / 2 : n.value;
 }
+function t(n) {
+  return !Number.isFinite(o(n));
+}
 export {
   i as isBandPoint,
+  t as isGapPoint,
   o as pointValue
 };

package/dist/core/dist/utils/time.js

@@ -1,30 +1,45 @@
-function m(e) {
+function l(e) {
   return e instanceof Date ? e.getTime() : e;
 }
-function c(e) {
-  return e.length === 0 || !e.some((t) => t.time instanceof Date) ? e : e.map((t) => ({ ...t, time: m(t.time) }));
-}
 function u(e) {
-  return e.length === 0 || !e.some((t) => t.time instanceof Date) ? e : e.map((t) => ({ ...t, time: m(t.time) }));
+  return e.length === 0 || !e.some((t) => t.time instanceof Date) ? e : e.map((t) => ({ ...t, time: l(t.time) }));
 }
-function l(e) {
-  if (e.length < 2) return 864e5;
+function s(e) {
+  return e.length === 0 || !e.some((t) => t.time instanceof Date) ? e : e.map((t) => ({ ...t, time: l(t.time) }));
+}
+const a = 19;
+function h(e) {
   const t = [];
-  for (let n = 1; n < Math.min(e.length, 20); n++)
-    t.push(e[n] - e[n - 1]);
-  return t.sort((n, i) => n - i), t[Math.floor(t.length / 2)];
+  for (let n = 1; n < e.length; n++) {
+    const r = e[n] - e[n - 1];
+    r > 0 && t.push(r);
+  }
+  if (t.length === 0) return 864e5;
+  if (t.length <= a) return c(t);
+  const o = Math.ceil(a / 2);
+  let i = Number.POSITIVE_INFINITY;
+  for (let n = a; i = Math.min(i, c(t.slice(n - a, n))), n !== t.length; n = Math.min(n + o, t.length))
+    ;
+  return i;
 }
-function s(e, t, n) {
-  const i = new Date(e), r = n?.locale ?? "en-US", o = n?.timeZone, a = n?.hour12 ?? !1;
-  return t >= 31536e6 ? i.toLocaleDateString(r, { year: "numeric", timeZone: o }) : t >= 864e5 ? i.toLocaleDateString(r, { month: "short", day: "numeric", timeZone: o }) : t >= 36e5 ? i.toLocaleTimeString(r, { hour: "2-digit", minute: "2-digit", hour12: a, timeZone: o }) : i.toLocaleTimeString(r, {
+function f(e, t) {
+  const { maxCount: o, from: i } = t;
+  return i === "start" ? e.slice(0, o) : e.slice(Math.max(0, e.length - o));
+}
+function c(e) {
+  return e.sort((t, o) => t - o), e[Math.floor(e.length / 2)];
+}
+function g(e, t, o) {
+  const i = new Date(e), n = o?.locale ?? "en-US", r = o?.timeZone, m = o?.hour12 ?? !1;
+  return t >= 31536e6 ? i.toLocaleDateString(n, { year: "numeric", timeZone: r }) : t >= 864e5 ? i.toLocaleDateString(n, { month: "short", day: "numeric", timeZone: r }) : t >= 36e5 ? i.toLocaleTimeString(n, { hour: "2-digit", minute: "2-digit", hour12: m, timeZone: r }) : i.toLocaleTimeString(n, {
     hour: "2-digit",
     minute: "2-digit",
     second: "2-digit",
-    hour12: a,
-    timeZone: o
+    hour12: m,
+    timeZone: r
   });
 }
-function f(e, t) {
+function d(e, t) {
   return new Date(e).toLocaleDateString(t?.locale ?? "en-US", {
     month: "short",
     day: "numeric",
@@ -32,16 +47,17 @@ function f(e, t) {
     timeZone: t?.timeZone
   });
 }
-function h(e) {
-  const t = [1e3, 5e3, 1e4, 15e3, 3e4], n = [6e4, 5 * 6e4, 10 * 6e4, 15 * 6e4, 30 * 6e4], i = [36e5, 2 * 36e5, 4 * 36e5, 6 * 36e5, 12 * 36e5], r = [864e5, 7 * 864e5, 30 * 864e5, 90 * 864e5], o = [31536e6, 2 * 31536e6, 5 * 31536e6, 10 * 31536e6, 25 * 31536e6, 50 * 31536e6, 100 * 31536e6];
-  return e < 6e4 ? [...t, ...n, ...i, ...r, ...o] : e < 36e5 ? [...n, ...i, ...r, ...o] : e < 864e5 ? [...i, ...r, ...o] : e < 31536e6 ? [...r, ...o] : o;
+function D(e) {
+  const t = [1e3, 5e3, 1e4, 15e3, 3e4], o = [6e4, 5 * 6e4, 10 * 6e4, 15 * 6e4, 30 * 6e4], i = [36e5, 2 * 36e5, 4 * 36e5, 6 * 36e5, 12 * 36e5], n = [864e5, 7 * 864e5, 30 * 864e5, 90 * 864e5], r = [31536e6, 2 * 31536e6, 5 * 31536e6, 10 * 31536e6, 25 * 31536e6, 50 * 31536e6, 100 * 31536e6];
+  return e < 6e4 ? [...t, ...o, ...i, ...n, ...r] : e < 36e5 ? [...o, ...i, ...n, ...r] : e < 864e5 ? [...i, ...n, ...r] : e < 31536e6 ? [...n, ...r] : r;
 }
 export {
-  l as detectInterval,
-  f as formatDate,
-  s as formatTime,
-  h as niceTimeIntervals,
-  c as normalizeOHLCArray,
-  m as normalizeTime,
-  u as normalizeTimePointArray
+  h as detectInterval,
+  d as formatDate,
+  g as formatTime,
+  D as niceTimeIntervals,
+  u as normalizeOHLCArray,
+  l as normalizeTime,
+  s as normalizeTimePointArray,
+  f as sliceSample
 };

package/dist/index.d.ts

@@ -16,6 +16,7 @@ gradient: boolean;
 theme: ChartTheme;
 interactive: boolean;
 headerLayout: "overlay" | "inline";
+animations: boolean | AnimationsConfig;
 }, {}, {}, {}, string, ComponentProvideOptions, false, {
 titleAnchor: HTMLDivElement;
 infoBarAnchor: HTMLDivElement;
@@ -49,7 +50,9 @@ declare const __VLS_component_7: DefineComponent<__VLS_Props_19, {}, {}, {}, {},
 containerRef: HTMLDivElement;
 }, any>;
 
-declare const __VLS_component_8: DefineComponent<__VLS_Props_22, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_22> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const __VLS_component_8: DefineComponent<__VLS_Props_22, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_22> & Readonly<{}>, {
+animate: YLabelAnimate;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
 
 declare type __VLS_Props = {
     /**
@@ -113,6 +116,7 @@ declare type __VLS_Props_13 = {
      */
     format?: ((value: number) => string) | Intl.NumberFormatOptions;
     locale?: string;
+    /** Per-digit spin duration in ms. A value that arrives sooner than this after the previous one snaps instead. */
     spinDuration?: number;
 };
 
@@ -287,7 +291,7 @@ declare type __VLS_Props_4 = {
      * Viewport padding. `top`/`bottom` are in pixels. `left`/`right` accept either pixels (`50`)
      * or data intervals (`{ intervals: 3 }`). Set to 0 for edge-to-edge sparklines. Updates are
      * applied reactively when this prop or the measured header height changes.
-     * Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0 } }`.
+     * Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0.5 } }`.
      */
     padding?: {
         top?: number;
@@ -305,19 +309,23 @@ declare type __VLS_Props_4 = {
      */
     viewport?: {
         /**
-         * Width of the visible window in data bars, set on the first data load
-         * to `maxVisibleBars * dataInterval`. While the dataset is smaller than
-         * this width, streaming ticks render into the empty right-side gap and
-         * the viewport stays put; once the data reaches the right edge, the
-         * viewport pans forward to keep the latest bar pinned (tail-scroll).
-         * Default: 200.
+         * Most bars the chart's own fit shows. The first data load fits every bar
+         * up to this count; while the data holds fewer, streamed bars widen the
+         * window, and once it is full the window keeps its width and follows the
+         * latest bar. `fitContent()` and an explicit bar count are not capped.
+         * Default: 200. Values below 2 are clamped.
          */
         maxVisibleBars?: number;
         /**
          * Initial visible range applied before the first paint with data. Same
          * shape as the imperative `chart.setVisibleRange` — pass a bar count
          * (e.g. `35`), an explicit `{from, to}` window, or `{from, bars}` for
-         * a warm-up pair. Captured at mount.
+         * a warm-up pair.
+         *
+         * It stays the chart's window until the user zooms or pans or the app
+         * sets a range, so a series that loads later or data set again keeps it.
+         * A bar count widens with streamed bars until it holds that many; a
+         * `{from, …}` window ends once streaming moves it. Captured at mount.
          */
         initialRange?: VisibleRangeSpec;
     };
@@ -329,7 +337,7 @@ declare type __VLS_Props_4 = {
      * two-way binding; a same-value literal (compared structurally) is a
      * no-op, so an inline object doesn't re-apply on every render.
      *
-     * For a one-shot initial window that isn't re-applied on every prop
+     * For an initial window that isn't re-applied on every prop
      * change, use `viewport.initialRange` instead.
      */
     visibleRange?: VisibleRangeSpec;
@@ -1721,7 +1729,7 @@ export declare interface BitmapCoordinateSpace {
  * actually be drawing.
  *
  * The result is cached per `(chart, cacheKey)` slot; as long as
- * `chart.getOverlayVersion()` hasn't changed and `time`/`sort` match the
+ * `chart.getSnapshotVersion()` hasn't changed and `time`/`sort` match the
  * cached call, the **same reference** is returned. This makes
  * `React.memo((a, b) => a.snapshots === b.snapshots)` skip renders on
  * crosshair moves that stay within one data point.
@@ -1748,7 +1756,7 @@ export declare interface BuildHoverSnapshotsArgs {
  * at the primary layer's timestamp.
  *
  * Cached by `(chart, cacheKey)` + `sort`, invalidated on
- * `chart.getOverlayVersion()` bump. `time` is not an input, so the slot is
+ * `chart.getSnapshotVersion()` bump. `time` is not an input, so the slot is
  * stored with `time: null`.
  */
 export declare function buildLastSnapshots(chart: ChartInstance, args: BuildLastSnapshotsArgs): readonly SeriesSnapshot[];
@@ -2075,6 +2083,13 @@ declare interface ChartEvents {
      * tracked tick has reached its target opacity.
      */
     tickFrame: () => void;
+    /**
+     * Fired once per main-layer frame while a series' displayed values animate
+     * (value smoothing, entrance, layer fade, intro), and once on the frame they
+     * settle. Snapshot readers (`InfoBar`, `Tooltip`) refresh off it, as
+     * `buildHoverSnapshots` / `buildLastSnapshots` report those animated values.
+     */
+    seriesFrame: () => void;
 }
 
 /**
@@ -2316,7 +2331,7 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
      */
     setLayerVisible(seriesId: string, layerIndex: number, visible: boolean): void;
     isLayerVisible(seriesId: string, layerIndex: number): boolean;
-    /** Auto-fit the viewport to show all data across every series. */
+    /** Auto-fit the viewport to show all data across every series, however many bars that is. */
     fitContent(): void;
     getVisibleRange(): XRange;
     /**
@@ -2609,6 +2624,7 @@ export declare class ChartInstance extends EventEmitter<ChartEvents> implements
     /** Compute the earliest and latest timestamps across all series. */
     private getDataBounds;
     private onDataChanged;
+    /** `full`: the data was replaced, so a long series is read whole instead of from its tail. */
     private updateDataInterval;
     /**
      * Shift the visible time range by `timeDelta` ms. Hard-clamped so at
@@ -2674,7 +2690,7 @@ export declare interface ChartOptions {
     scales?: Record<string, YAxisConfig>;
     /**
      * Viewport padding. `top`/`bottom` are in pixels. `left`/`right` accept either pixels (`50`)
-     * or data intervals (`{ intervals: 3 }`). Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0 } }`.
+     * or data intervals (`{ intervals: 3 }`). Defaults: `{ top: 20, bottom: 20, right: { intervals: 3 }, left: { intervals: 0.5 } }`.
      */
     padding?: {
         top?: number;
@@ -2687,11 +2703,10 @@ export declare interface ChartOptions {
      */
     viewport?: {
         /**
-         * Maximum number of data bars (candles/points) the viewport will fit
-         * before it stops growing and switches to tail-scroll. While the data
-         * span is below this threshold, streaming ticks expand the right edge
-         * to absorb new points; once the span exceeds it, the visible window
-         * holds at this width and slides forward as new data arrives.
+         * Most bars the chart's own fit shows. The first data load fits every bar
+         * up to this count; while the data holds fewer, streamed bars widen the
+         * window, and once it is full the window keeps its width and follows the
+         * latest bar. `fitContent()` and an explicit bar count are not capped.
          * Default: 200. Values below 2 are clamped.
          */
         maxVisibleBars?: number;
@@ -2704,8 +2719,10 @@ export declare interface ChartOptions {
          * the same intent into the first render so the very first paint
          * already shows the requested window.
          *
-         * One-shot — consumed by the first `onDataChanged` call that has data,
-         * then cleared. Subsequent `setSeriesData` calls don't re-apply it.
+         * It stays the chart's window until the user zooms or pans or the app
+         * sets a range, so a series that loads later or data set again keeps it.
+         * A bar count widens with streamed bars until it holds that many; a
+         * `{from, …}` window ends once streaming moves it.
          */
         initialRange?: VisibleRangeSpec;
     };
@@ -3077,7 +3094,12 @@ containerRef: HTMLDivElement;
 export { _default as TimeAxis }
 export { _default as XAxis }
 
-export declare function detectInterval(times: number[]): number;
+/**
+ * The bar step of an ascending time array: the smallest median step over any
+ * run of 20 points, so a series that switches to a finer resolution part-way
+ * through is sized for its finest part. `DAY` without two distinct times.
+ */
+export declare function detectInterval(times: readonly number[]): number;
 
 export declare const dracula: ThemePreset;
 
@@ -3339,6 +3361,8 @@ export declare interface LayerSnapshot {
     high?: number;
     /** The sample's own X on a numeric or category axis. */
     x?: number | string;
+    /** On a percent stack, the row's percent of the rows listed with it. Absent elsewhere, and when they sum to 0. */
+    share?: number;
 }
 
 export declare const Legend: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;
@@ -4758,6 +4782,12 @@ export declare interface SeriesCreateEnv {
     theme: ChartTheme;
     /** Number of stacked layers requested via `layers` (`1` when omitted). */
     layerCount: number;
+    /**
+     * First `theme.seriesColors` slot for this series' default layer colours:
+     * the lowest run of `layerCount` slots no other series of the same type
+     * holds, so two series don't both default to the first colour. `0` when omitted.
+     */
+    paletteIndex?: number;
 }
 
 /**
@@ -4867,6 +4897,8 @@ export declare interface SeriesSnapshot {
     readonly label?: string;
     readonly data: Readonly<OHLCData> | Readonly<TimePoint> | Readonly<BandPoint>;
     readonly color: string;
+    /** On a percent stack, the layer's share of the column in percent — what the chart draws it at. */
+    readonly share?: number;
 }
 
 /** Primary series types. Open-ended — a custom {@link SeriesDefinition} picks any string that isn't a built-in. */
@@ -5092,9 +5124,10 @@ export declare interface TimePoint {
     x?: number | string;
 }
 
-/** {@link TimePoint} that also accepts `Date` for the time field. */
-export declare type TimePointInput = Omit<TimePoint, 'time' | 'x'> & {
+/** {@link TimePoint} that also accepts `Date` for the time field, and `null` for a gap. */
+export declare type TimePointInput = Omit<TimePoint, 'time' | 'x' | 'value'> & {
     time: TimeValue;
+    value: number | null;
 };
 
 export declare const TimeRegion: DefineComponent<__VLS_Props_17, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<__VLS_Props_17> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
@@ -5147,8 +5180,11 @@ export declare interface TimeSeriesRenderer extends BaseSeriesRenderer {
     getLastDataPoint(): OHLCData | TimePoint | BandPoint | null;
     /** Second-to-last data point (layer 0 for multi-layer), or null. */
     getSecondLastDataPoint(): OHLCData | TimePoint | BandPoint | null;
-    /** First `maxCount` sample times from the first populated layer — feeds interval detection. */
-    sampleTimes(maxCount: number): number[];
+    /**
+     * First `maxCount` sample times from the first populated layer — feeds
+     * interval detection. With `'end'`, the last `maxCount` of that same layer.
+     */
+    sampleTimes(maxCount: number, from?: 'start' | 'end'): number[];
     /** Visible points in `[from, to]` (layer 0 for multi-layer). */
     getVisibleDataPoints(from: number, to: number): readonly (OHLCData | TimePoint | BandPoint)[];
     /**
@@ -5526,7 +5562,8 @@ export declare interface XBandPointInput {
  */
 export declare interface XPointInput {
     x: number | string;
-    value: number;
+    /** `null` (or any non-finite value) is a gap: the line breaks there and the tooltip leaves the point out. */
+    value: number | null;
 }
 
 /** Time range (timestamps in milliseconds) of the currently visible portion of the chart. */
@@ -5654,7 +5691,9 @@ export declare class XScale {
     barWidthMedia(dataInterval: number): number;
     barWidthBitmap(dataInterval: number): number;
     /**
-     * Evenly spaced "nice" tick times. Resolution uses the cached
+     * "Nice" tick values. A time axis puts them on calendar boundaries in the
+     * installed time zone (Jan 1, the 1st of a month, midnight), so their gaps
+     * vary; `tickInterval` is the tier's nominal span. Resolution uses the cached
      * `dataInterval` set by `update()`; callers that bypass `update()` can
      * still pass it here for back-compat.
      */