minerva-design 1.3.0 → 1.5.0

package/dist/charts/engine/trading/scale.js

@@ -0,0 +1,100 @@
+import { tickStep as e } from "../scale.js";
+//#region src/engine/trading/scale.ts
+var t = (e = "linear") => ({
+	mode: e,
+	auto: !0,
+	min: 0,
+	max: 1,
+	base: 1,
+	top: 0,
+	height: 1,
+	marginTop: .1,
+	marginBottom: .1
+}), n = (e, t) => {
+	switch (e.mode) {
+		case "log": return t > 0 ? Math.log10(t) : NaN;
+		case "percent": return e.base ? (t / e.base - 1) * 100 : NaN;
+		default: return t;
+	}
+}, r = (e, t) => {
+	switch (e.mode) {
+		case "log": return 10 ** t;
+		case "percent": return (t / 100 + 1) * e.base;
+		default: return t;
+	}
+}, i = (e) => {
+	let t = e.top + e.height * e.marginTop, n = e.height * (1 - e.marginTop - e.marginBottom);
+	return {
+		top: t,
+		h: Math.max(1, n)
+	};
+}, a = (e, t) => {
+	let { top: n, h: r } = i(e), a = e.max - e.min || 1;
+	return n + (e.max - t) / a * r;
+}, o = (e, t) => a(e, n(e, t)), s = (e, t) => {
+	let { top: n, h: r } = i(e);
+	return e.max - (t - n) / r * (e.max - e.min || 1);
+}, c = (e, t) => r(e, s(e, t)), l = (e, t, n) => {
+	let r = t, i = n;
+	if (!Number.isFinite(r) || !Number.isFinite(i)) {
+		(!Number.isFinite(e.min) || !Number.isFinite(e.max)) && (e.min = 0, e.max = 1);
+		return;
+	}
+	if (r > i && ([r, i] = [i, r]), i - r < 1e-12 * Math.max(1, Math.abs(r))) {
+		let t = e.mode === "log" ? .01 : Math.max(Math.abs(r) * .01, 1e-8) || 1;
+		r -= t, i += t;
+	}
+	e.min = r, e.max = i;
+}, u = (e, t) => {
+	let n = (e.min + e.max) / 2, r = (e.max - e.min) / 2 * t;
+	r > 0 && Number.isFinite(r) && (e.min = n - r, e.max = n + r, e.auto = !1);
+}, d = (e, t) => {
+	let { h: n } = i(e), r = t / n * (e.max - e.min);
+	e.min += r, e.max += r, e.auto = !1;
+}, f = (e) => {
+	if (!(e > 0)) return e;
+	let t = 10 ** Math.floor(Math.log10(e)), n = e / t, r = [
+		1,
+		1.2,
+		1.5,
+		2,
+		2.5,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		10
+	], i = r[0];
+	for (let e of r) Math.abs(e - n) < Math.abs(i - n) && (i = e);
+	return i * t;
+}, p = (t, n = 36) => {
+	let { h: r } = i(t), a = (t.max - t.min) * t.height / r, o = t.max - a * (1 - t.marginTop) - 1e-12, s = t.max + a * t.marginTop + 1e-12, c = Math.max(2, Math.floor(t.height / n)), l = e(o, s, c);
+	if (!(l > 0)) return {
+		scaled: [],
+		step: 0
+	};
+	let u = [];
+	if (t.mode === "log") {
+		let e = NaN;
+		for (let r = Math.ceil(o / l) * l; r <= s; r += l) {
+			let i = f(10 ** r), c = Math.log10(i);
+			c === e || c < o || c > s || u.length && (c - u[u.length - 1]) / a * t.height < n * .5 || (u.push(c), e = c);
+		}
+		return {
+			scaled: u,
+			step: l
+		};
+	}
+	let d = Math.ceil(o / l - 1e-9), p = Math.floor(s / l + 1e-9);
+	for (let e = d; e <= p && u.length < 200; e++) u.push(e * l);
+	return {
+		scaled: u,
+		step: l
+	};
+};
+//#endregion
+export { t as createScale, l as fitScale, r as fromScaled, d as panScale, p as scaleTicks, s as scaledAt, n as toScaled, c as valueAt, o as yOf, a as yOfScaled, u as zoomScale };
+
+//# sourceMappingURL=scale.js.map

package/dist/charts/engine/trading/scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale.js","names":["createScale","toScaled","scale","value","fromScaled","scaled","band","top","h","yOfScaled","span","yOf","scaledAt","y","valueAt","fitScale","a","lo","b","hi","pad","zoomScale","mid","half","factor","panScale","delta","dy","niceRound","power","m","steps","best","s","scaleTicks","extra","count","minGap","step","tickStep","previous","t","price","start","end","i"],"sources":["../../../../../charts/src/engine/trading/scale.ts"],"sourcesContent":["// Vertical scales of the panes: linear, logarithmic or percent (change from\n// a base price). Values are mapped to a \"scaled\" space (the price, its\n// log10, or the percent change) in which the scale is linear.\n\nimport { tickStep } from \"../scale\";\nimport type { TradingScaleMode } from \"./types\";\n\nexport interface PaneScale {\n  mode: TradingScaleMode;\n  /** Fits the visible values (off after the user zoomed the scale) */\n  auto: boolean;\n  /** Visible range in scaled space */\n  min: number;\n  max: number;\n  /** Base price of the percent mode */\n  base: number;\n  /** Pane position in CSS pixels */\n  top: number;\n  height: number;\n  /** Empty space above / below the values, as fractions of the height */\n  marginTop: number;\n  marginBottom: number;\n}\n\nexport const createScale = (mode: TradingScaleMode = \"linear\"): PaneScale => ({\n  mode,\n  auto: true,\n  min: 0,\n  max: 1,\n  base: 1,\n  top: 0,\n  height: 1,\n  marginTop: 0.1,\n  marginBottom: 0.1,\n});\n\n/** Value -> scaled space (NaN when it has no place, e.g. log of <= 0) */\nexport const toScaled = (scale: PaneScale, value: number): number => {\n  switch (scale.mode) {\n    case \"log\":\n      return value > 0 ? Math.log10(value) : NaN;\n    case \"percent\":\n      return scale.base ? (value / scale.base - 1) * 100 : NaN;\n    default:\n      return value;\n  }\n};\n\nexport const fromScaled = (scale: PaneScale, scaled: number): number => {\n  switch (scale.mode) {\n    case \"log\":\n      return 10 ** scaled;\n    case \"percent\":\n      return (scaled / 100 + 1) * scale.base;\n    default:\n      return scaled;\n  }\n};\n\n/** Inner band of the pane holding the range (CSS px) */\nconst band = (scale: PaneScale) => {\n  const top = scale.top + scale.height * scale.marginTop;\n  const h = scale.height * (1 - scale.marginTop - scale.marginBottom);\n  return { top, h: Math.max(1, h) };\n};\n\n/** CSS y of a scaled value */\nexport const yOfScaled = (scale: PaneScale, scaled: number): number => {\n  const { top, h } = band(scale);\n  const span = scale.max - scale.min || 1;\n  return top + ((scale.max - scaled) / span) * h;\n};\n\n/** CSS y of a value */\nexport const yOf = (scale: PaneScale, value: number): number =>\n  yOfScaled(scale, toScaled(scale, value));\n\n/** Scaled value at a CSS y */\nexport const scaledAt = (scale: PaneScale, y: number): number => {\n  const { top, h } = band(scale);\n  return scale.max - ((y - top) / h) * (scale.max - scale.min || 1);\n};\n\n/** Value at a CSS y */\nexport const valueAt = (scale: PaneScale, y: number): number =>\n  fromScaled(scale, scaledAt(scale, y));\n\n/**\n * Fits the scale to a range of scaled values; a flat range gets some room\n * around it, a missing one keeps the current range\n */\nexport const fitScale = (scale: PaneScale, lo: number, hi: number): void => {\n  let a = lo;\n  let b = hi;\n  if (!Number.isFinite(a) || !Number.isFinite(b)) {\n    if (!Number.isFinite(scale.min) || !Number.isFinite(scale.max)) {\n      scale.min = 0;\n      scale.max = 1;\n    }\n    return;\n  }\n  if (a > b) [a, b] = [b, a];\n  if (b - a < 1e-12 * Math.max(1, Math.abs(a))) {\n    const pad =\n      scale.mode === \"log\" ? 0.01 : Math.max(Math.abs(a) * 0.01, 1e-8) || 1;\n    a -= pad;\n    b += pad;\n  }\n  scale.min = a;\n  scale.max = b;\n};\n\n/** Zooms the range around its center (factor > 1 shows more) */\nexport const zoomScale = (scale: PaneScale, factor: number): void => {\n  const mid = (scale.min + scale.max) / 2;\n  const half = ((scale.max - scale.min) / 2) * factor;\n  if (!(half > 0) || !Number.isFinite(half)) return;\n  scale.min = mid - half;\n  scale.max = mid + half;\n  scale.auto = false;\n};\n\n/** Moves the range by a number of CSS pixels (positive: content goes down) */\nexport const panScale = (scale: PaneScale, dy: number): void => {\n  const { h } = band(scale);\n  const delta = (dy / h) * (scale.max - scale.min);\n  scale.min += delta;\n  scale.max += delta;\n  scale.auto = false;\n};\n\n/** Rounds to 2 significant digits (1, 1.5, 2, 2.5, 3, ...) for log ticks */\nconst niceRound = (value: number): number => {\n  if (!(value > 0)) return value;\n  const power = 10 ** Math.floor(Math.log10(value));\n  const m = value / power;\n  const steps = [1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 7, 8, 10];\n  let best = steps[0];\n  for (const s of steps) if (Math.abs(s - m) < Math.abs(best - m)) best = s;\n  return best * power;\n};\n\n/**\n * Ticks of the scale in scaled space, about `minGap` CSS pixels apart.\n * Log ticks are rounded prices; percent ticks are round percents.\n */\nexport const scaleTicks = (\n  scale: PaneScale,\n  minGap = 36,\n): { scaled: number[]; step: number } => {\n  const { h } = band(scale);\n  // the range covered by the whole pane, margins included\n  const span = scale.max - scale.min;\n  const extra = (span * scale.height) / h;\n  const lo = scale.max - extra * (1 - scale.marginTop) - 1e-12;\n  const hi = scale.max + extra * scale.marginTop + 1e-12;\n  const count = Math.max(2, Math.floor(scale.height / minGap));\n  const step = tickStep(lo, hi, count);\n  if (!(step > 0)) return { scaled: [], step: 0 };\n  const scaled: number[] = [];\n  if (scale.mode === \"log\") {\n    let previous = NaN;\n    for (let t = Math.ceil(lo / step) * step; t <= hi; t += step) {\n      const price = niceRound(10 ** t);\n      const s = Math.log10(price);\n      if (s === previous || s < lo || s > hi) continue;\n      // keep the ticks at least half the gap apart once rounded\n      if (\n        scaled.length &&\n        ((s - scaled[scaled.length - 1]) / extra) * scale.height < minGap * 0.5\n      )\n        continue;\n      scaled.push(s);\n      previous = s;\n    }\n    return { scaled, step };\n  }\n  const start = Math.ceil(lo / step - 1e-9);\n  const end = Math.floor(hi / step + 1e-9);\n  for (let i = start; i <= end && scaled.length < 200; i++)\n    scaled.push(i * step);\n  return { scaled, step };\n};\n"],"mappings":"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"}

package/dist/charts/engine/trading/store.cjs

@@ -0,0 +1,2 @@
+var e=[`time`,`open`,`high`,`low`,`close`,`volume`],t=e=>!Array.isArray(e),n=e=>t(e)?Math.min(e.time.length,e.open.length,e.high.length,e.low.length,e.close.length):e.length,r=e=>({time:new Float64Array(e),open:new Float64Array(e),high:new Float64Array(e),low:new Float64Array(e),close:new Float64Array(e),volume:new Float64Array(e)}),i=()=>({...r(16),length:0,capacity:16,hasVolume:!1}),a=(t,n)=>{if(n<=t.capacity)return;let i=t.capacity;for(;i<n;)i*=2;let a=r(i);for(let n of e)a[n].set(t[n].subarray(0,t.length));Object.assign(t,a),t.capacity=i},o=(e,n,r,i)=>{if(t(n)){for(let t=0;t<i;t++)e.time[r+t]=n.time[t],e.open[r+t]=n.open[t],e.high[r+t]=n.high[t],e.low[r+t]=n.low[t],e.close[r+t]=n.close[t];let t=n.volume;if(t){for(let n=0;n<i;n++){let i=t[n];e.volume[r+n]=Number.isFinite(i)?i:0}e.hasVolume=!0}else e.volume.fill(0,r,r+i);return}for(let t=0;t<i;t++)s(e,r+t,n[t])},s=(e,t,n)=>{e.time[t]=n.time,e.open[t]=n.open,e.high[t]=n.high,e.low[t]=n.low,e.close[t]=n.close;let r=n.volume;r!==void 0&&Number.isFinite(r)?(e.volume[t]=r,e.hasVolume=!0):e.volume[t]=0},c=(e,t)=>{let r=n(t);e.length=0,e.hasVolume=!1,a(e,r),o(e,t,0,r),e.length=r},l=(e,t)=>{let r=n(t),i=-1;for(let n=0;n<r;n++){let r=d(e,u(t,n));r>=0&&(i<0||r<i)&&(i=r)}return i},u=(e,n)=>t(e)?{time:e.time[n],open:e.open[n],high:e.high[n],low:e.low[n],close:e.close[n],...e.volume?{volume:e.volume[n]}:{}}:e[n],d=(e,t)=>{let n=e.length;if(!Number.isFinite(t.time))return-1;if(n>0){let r=e.time[n-1];if(t.time<r)return-1;if(t.time===r)return s(e,n-1,t),n-1}return a(e,n+1),s(e,n,t),e.length=n+1,n},f=(r,i)=>{let s=n(i),c=r.length?r.time[0]:1/0,l=0,u=t(i)?i.time:null;for(;l<s&&(u?u[l]:i[l].time)<c;)l++;if(!l)return 0;let d=r.length,f={time:r.time.slice(0,d),open:r.open.slice(0,d),high:r.high.slice(0,d),low:r.low.slice(0,d),close:r.close.slice(0,d),volume:r.volume.slice(0,d)};r.length=0,a(r,d+l),o(r,i,0,l);for(let t of e)r[t].set(f[t],l);return r.length=d+l,l},p=(e,t)=>({time:e.time[t],open:e.open[t],high:e.high[t],low:e.low[t],close:e.close[t],volume:e.volume[t]}),m=(e,t,n)=>{let r=0,i=t;for(;r<i;){let t=r+i>>>1;e[t]<n?r=t+1:i=t}return r},h=(e,t,n)=>{let r=m(e,t,n);return r<t&&e[r]===n?r:Math.max(0,r-1)},g=()=>({levels:[]}),_=(t,n,i,a)=>{let o=2**a,s=Math.ceil(i/o),c=t.levels[a];if(!c||c.time.length<s){let n={...r(Math.max(16,Math.ceil(s*1.5))),size:o,valid:0};if(c){for(let t of e)n[t].set(c[t].subarray(0,c.valid));n.valid=c.valid}c=n,t.levels[a]=c}if(c.valid>=s)return c;let l=a>1?_(t,n,i,a-1):n,u=a>1?Math.ceil(i/(o/2)):i,d=Math.max(0,Math.min(c.valid,s-1));for(let e=d;e<s;e++){let t=e*2,n=t+1;c.time[e]=l.time[t],c.open[e]=l.open[t],n<u?(c.high[e]=Math.max(l.high[t],l.high[n]),c.low[e]=Math.min(l.low[t],l.low[n]),c.close[e]=l.close[n],c.volume[e]=l.volume[t]+l.volume[n]):(c.high[e]=l.high[t],c.low[e]=l.low[t],c.close[e]=l.close[t],c.volume[e]=l.volume[t])}return c.valid=i%o===0?s:s-1,c},v=()=>({levels:[]}),y=(e,t)=>{for(let n of e.levels)n&&(n.valid=Math.min(n.valid,Math.floor(t/n.size)))},b=(e,t)=>Number.isFinite(e)?Number.isFinite(t)?e<t?e:t:e:t,x=(e,t)=>Number.isFinite(e)?Number.isFinite(t)?e>t?e:t:e:t,S=(e,t,n,r)=>{let i=2**r,a=Math.ceil(n/i),o=e.levels[r];if(!o||o.min.length<a){let t=Math.max(16,Math.ceil(a*1.5)),n={size:i,min:new Float64Array(t),max:new Float64Array(t),last:new Float64Array(t),valid:0};o&&(n.min.set(o.min.subarray(0,o.valid)),n.max.set(o.max.subarray(0,o.valid)),n.last.set(o.last.subarray(0,o.valid)),n.valid=o.valid),o=n,e.levels[r]=o}if(o.valid>=a)return o;let s=r>1?S(e,t,n,r-1):null,c=r>1?Math.ceil(n/(i/2)):n,l=Math.max(0,Math.min(o.valid,a-1));for(let e=l;e<a;e++){let n=e*2,r=n+1,i=r<c,a=s?s.min[n]:t[n],l=s?s.max[n]:t[n],u=s?s.last[n]:t[n],d=i?s?s.min[r]:t[r]:NaN,f=i?s?s.max[r]:t[r]:NaN,p=i?s?s.last[r]:t[r]:NaN;o.min[e]=b(a,d),o.max[e]=x(l,f),o.last[e]=Number.isFinite(p)?p:u}return o.valid=n%i===0?a:a-1,o};exports.appendBars=l,exports.barAt=u,exports.createPyramid=g,exports.createRangePyramid=v,exports.createStore=i,exports.indexOfTime=h,exports.inputLength=n,exports.invalidateRangePyramid=y,exports.lowerBoundTime=m,exports.prependBars=f,exports.pyramidLevel=_,exports.rangeLevel=S,exports.readBar=p,exports.setBars=c,exports.updateBar=d;
+//# sourceMappingURL=store.cjs.map

package/dist/charts/engine/trading/store.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.cjs","names":["KEYS","isColumns","bars","inputLength","allocate","capacity","createStore","reserve","size","store","next","key","write","i","count","at","volume","v","writeBar","bar","setBars","n","appendBars","first","updateBar","barAt","last","prependBars","time","length","previous","readBar","columns","lowerBoundTime","lo","hi","mid","value","indexOfTime","createPyramid","pyramidLevel","k","groups","level","pyramid","prev","src","prevCount","from","g","a","b","createRangePyramid","invalidateRangePyramid","lower","upper","rangeLevel","values","has","minA","maxA","lastA","minB","maxB","lastB"],"sources":["../../../../../charts/src/engine/trading/store.ts"],"sourcesContent":["// Bars in growable Float64Array columns, and a pyramid of aggregated\n// levels (2, 4, 8, ... bars per group) drawn when the chart is zoomed out\n// so far that a bar is narrower than a pixel: a million bars cost the\n// same to draw as a thousand.\n\nimport type { TradingBar, TradingBarColumns, TradingBarsInput } from \"./types\";\n\n/** OHLCV columns; only the first `length` entries are meaningful */\nexport interface OhlcColumns {\n  time: Float64Array;\n  open: Float64Array;\n  high: Float64Array;\n  low: Float64Array;\n  close: Float64Array;\n  volume: Float64Array;\n}\n\nexport interface BarStore extends OhlcColumns {\n  length: number;\n  /** Size of the columns */\n  capacity: number;\n  /** Some bar has a volume */\n  hasVolume: boolean;\n}\n\nconst KEYS = [\"time\", \"open\", \"high\", \"low\", \"close\", \"volume\"] as const;\n\nconst isColumns = (bars: TradingBarsInput): bars is TradingBarColumns =>\n  !Array.isArray(bars);\n\nexport const inputLength = (bars: TradingBarsInput): number =>\n  isColumns(bars)\n    ? Math.min(\n        bars.time.length,\n        bars.open.length,\n        bars.high.length,\n        bars.low.length,\n        bars.close.length,\n      )\n    : bars.length;\n\nconst allocate = (capacity: number): OhlcColumns => ({\n  time: new Float64Array(capacity),\n  open: new Float64Array(capacity),\n  high: new Float64Array(capacity),\n  low: new Float64Array(capacity),\n  close: new Float64Array(capacity),\n  volume: new Float64Array(capacity),\n});\n\nexport const createStore = (): BarStore => ({\n  ...allocate(16),\n  length: 0,\n  capacity: 16,\n  hasVolume: false,\n});\n\n/** Grows the columns to hold at least `size` bars (doubling) */\nconst reserve = (store: BarStore, size: number) => {\n  if (size <= store.capacity) return;\n  let capacity = store.capacity;\n  while (capacity < size) capacity *= 2;\n  const next = allocate(capacity);\n  for (const key of KEYS) next[key].set(store[key].subarray(0, store.length));\n  Object.assign(store, next);\n  store.capacity = capacity;\n};\n\n/** Writes `count` bars of `bars` at `at` */\nconst write = (\n  store: BarStore,\n  bars: TradingBarsInput,\n  at: number,\n  count: number,\n) => {\n  if (isColumns(bars)) {\n    for (let i = 0; i < count; i++) {\n      store.time[at + i] = bars.time[i];\n      store.open[at + i] = bars.open[i];\n      store.high[at + i] = bars.high[i];\n      store.low[at + i] = bars.low[i];\n      store.close[at + i] = bars.close[i];\n    }\n    const volume = bars.volume;\n    if (volume) {\n      for (let i = 0; i < count; i++) {\n        const v = volume[i];\n        store.volume[at + i] = Number.isFinite(v) ? v : 0;\n      }\n      store.hasVolume = true;\n    } else {\n      store.volume.fill(0, at, at + count);\n    }\n    return;\n  }\n  for (let i = 0; i < count; i++) writeBar(store, at + i, bars[i]);\n};\n\nconst writeBar = (store: BarStore, i: number, bar: TradingBar) => {\n  store.time[i] = bar.time;\n  store.open[i] = bar.open;\n  store.high[i] = bar.high;\n  store.low[i] = bar.low;\n  store.close[i] = bar.close;\n  const v = bar.volume;\n  if (v !== undefined && Number.isFinite(v)) {\n    store.volume[i] = v;\n    store.hasVolume = true;\n  } else {\n    store.volume[i] = 0;\n  }\n};\n\n/** Replaces every bar */\nexport const setBars = (store: BarStore, bars: TradingBarsInput): void => {\n  const n = inputLength(bars);\n  store.length = 0;\n  store.hasVolume = false;\n  reserve(store, n);\n  write(store, bars, 0, n);\n  store.length = n;\n};\n\n/**\n * Appends the bars newer than the last one (a bar at the time of the last\n * one replaces it). Returns the index of the first changed bar, or -1.\n */\nexport const appendBars = (store: BarStore, bars: TradingBarsInput): number => {\n  const n = inputLength(bars);\n  let first = -1;\n  for (let i = 0; i < n; i++) {\n    const at = updateBar(store, barAt(bars, i));\n    if (at >= 0 && (first < 0 || at < first)) first = at;\n  }\n  return first;\n};\n\n/** The `i`-th bar of an input */\nexport const barAt = (bars: TradingBarsInput, i: number): TradingBar => {\n  if (!isColumns(bars)) return bars[i];\n  return {\n    time: bars.time[i],\n    open: bars.open[i],\n    high: bars.high[i],\n    low: bars.low[i],\n    close: bars.close[i],\n    ...(bars.volume ? { volume: bars.volume[i] } : {}),\n  };\n};\n\n/**\n * Streams a bar: replaces the last bar at the same time, appends a newer\n * one. Returns its index; -1 (ignored) when older than the last bar.\n */\nexport const updateBar = (store: BarStore, bar: TradingBar): number => {\n  const n = store.length;\n  if (!Number.isFinite(bar.time)) return -1;\n  if (n > 0) {\n    const last = store.time[n - 1];\n    if (bar.time < last) return -1;\n    if (bar.time === last) {\n      writeBar(store, n - 1, bar);\n      return n - 1;\n    }\n  }\n  reserve(store, n + 1);\n  writeBar(store, n, bar);\n  store.length = n + 1;\n  return n;\n};\n\n/** Inserts the bars older than the first one; returns how many were added */\nexport const prependBars = (\n  store: BarStore,\n  bars: TradingBarsInput,\n): number => {\n  const n = inputLength(bars);\n  const first = store.length ? store.time[0] : Infinity;\n  // keep only the bars strictly older than the current first bar\n  let count = 0;\n  const time = isColumns(bars) ? bars.time : null;\n  while (\n    count < n &&\n    (time ? time[count] : (bars as readonly TradingBar[])[count].time) < first\n  ) {\n    count++;\n  }\n  if (!count) return 0;\n  const length = store.length;\n  const previous: OhlcColumns = {\n    time: store.time.slice(0, length),\n    open: store.open.slice(0, length),\n    high: store.high.slice(0, length),\n    low: store.low.slice(0, length),\n    close: store.close.slice(0, length),\n    volume: store.volume.slice(0, length),\n  };\n  store.length = 0;\n  reserve(store, length + count);\n  write(store, bars, 0, count);\n  for (const key of KEYS) store[key].set(previous[key], count);\n  store.length = length + count;\n  return count;\n};\n\n/** Bar at an index as an object */\nexport const readBar = (columns: OhlcColumns, i: number): TradingBar => ({\n  time: columns.time[i],\n  open: columns.open[i],\n  high: columns.high[i],\n  low: columns.low[i],\n  close: columns.close[i],\n  volume: columns.volume[i],\n});\n\n/** First index whose time is >= `time` (binary search) */\nexport const lowerBoundTime = (\n  time: Float64Array,\n  n: number,\n  value: number,\n): number => {\n  let lo = 0;\n  let hi = n;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    if (time[mid] < value) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n};\n\n/**\n * Index of the bar containing `time`: the last bar opening at or before it\n * (0 before the first bar)\n */\nexport const indexOfTime = (\n  time: Float64Array,\n  n: number,\n  value: number,\n): number => {\n  const i = lowerBoundTime(time, n, value);\n  if (i < n && time[i] === value) return i;\n  return Math.max(0, i - 1);\n};\n\n// ---------------------------------------------------------------- pyramid\n\n/** Bars aggregated `size` by `size`, aligned on index 0 */\nexport interface LodLevel extends OhlcColumns {\n  size: number;\n  /** Groups up to date */\n  valid: number;\n}\n\n/** Aggregated levels, built lazily; level k groups 2^k bars */\nexport interface Pyramid {\n  levels: (LodLevel | undefined)[];\n}\n\nexport const createPyramid = (): Pyramid => ({ levels: [] });\n\n/** Marks the groups containing bars from `from` on as stale */\nexport const invalidatePyramid = (pyramid: Pyramid, from: number): void => {\n  for (const level of pyramid.levels) {\n    if (level)\n      level.valid = Math.min(level.valid, Math.floor(from / level.size));\n  }\n};\n\n/**\n * Level `k` (k >= 1) of `src` (the first `n` bars), computed from level\n * k - 1 for the stale groups only\n */\nexport const pyramidLevel = (\n  pyramid: Pyramid,\n  src: OhlcColumns,\n  n: number,\n  k: number,\n): LodLevel => {\n  const size = 2 ** k;\n  const groups = Math.ceil(n / size);\n  let level = pyramid.levels[k];\n  if (!level || level.time.length < groups) {\n    const capacity = Math.max(16, Math.ceil(groups * 1.5));\n    const next: LodLevel = { ...allocate(capacity), size, valid: 0 };\n    if (level) {\n      for (const key of KEYS)\n        next[key].set(level[key].subarray(0, level.valid));\n      next.valid = level.valid;\n    }\n    level = next;\n    pyramid.levels[k] = level;\n  }\n  if (level.valid >= groups) return level;\n  // the source of level k: level k - 1 (pairs) or the bars (k = 1)\n  const prev = k > 1 ? pyramidLevel(pyramid, src, n, k - 1) : src;\n  const prevCount = k > 1 ? Math.ceil(n / (size / 2)) : n;\n  // the last group of a level may be partial: always recompute it\n  const from = Math.max(0, Math.min(level.valid, groups - 1));\n  for (let g = from; g < groups; g++) {\n    const a = g * 2;\n    const b = a + 1;\n    level.time[g] = prev.time[a];\n    level.open[g] = prev.open[a];\n    if (b < prevCount) {\n      level.high[g] = Math.max(prev.high[a], prev.high[b]);\n      level.low[g] = Math.min(prev.low[a], prev.low[b]);\n      level.close[g] = prev.close[b];\n      level.volume[g] = prev.volume[a] + prev.volume[b];\n    } else {\n      level.high[g] = prev.high[a];\n      level.low[g] = prev.low[a];\n      level.close[g] = prev.close[a];\n      level.volume[g] = prev.volume[a];\n    }\n  }\n  // complete groups stay valid; the partial last one is redone next time\n  level.valid = n % size === 0 ? groups : groups - 1;\n  return level;\n};\n\n// ---------------------------------------------------------- value ranges\n\n/** Lowest, highest and last finite value of each group of 2^k values */\nexport interface RangeLevel {\n  size: number;\n  min: Float64Array;\n  max: Float64Array;\n  last: Float64Array;\n  /** Groups up to date */\n  valid: number;\n}\n\n/**\n * Aggregated levels of a column of indicator values: a zoomed-out chart\n * draws the range of each group (min / max decimation), so spikes stay\n * visible instead of being sampled away\n */\nexport interface RangePyramid {\n  levels: (RangeLevel | undefined)[];\n}\n\nexport const createRangePyramid = (): RangePyramid => ({ levels: [] });\n\nexport const invalidateRangePyramid = (\n  pyramid: RangePyramid,\n  from: number,\n): void => {\n  for (const level of pyramid.levels) {\n    if (level)\n      level.valid = Math.min(level.valid, Math.floor(from / level.size));\n  }\n};\n\nconst lower = (a: number, b: number) =>\n  !Number.isFinite(a) ? b : !Number.isFinite(b) ? a : a < b ? a : b;\nconst upper = (a: number, b: number) =>\n  !Number.isFinite(a) ? b : !Number.isFinite(b) ? a : a > b ? a : b;\n\n/** Level `k` (k >= 1) of the first `n` values, updated for the stale groups only */\nexport const rangeLevel = (\n  pyramid: RangePyramid,\n  values: Float64Array,\n  n: number,\n  k: number,\n): RangeLevel => {\n  const size = 2 ** k;\n  const groups = Math.ceil(n / size);\n  let level = pyramid.levels[k];\n  if (!level || level.min.length < groups) {\n    const capacity = Math.max(16, Math.ceil(groups * 1.5));\n    const next: RangeLevel = {\n      size,\n      min: new Float64Array(capacity),\n      max: new Float64Array(capacity),\n      last: new Float64Array(capacity),\n      valid: 0,\n    };\n    if (level) {\n      next.min.set(level.min.subarray(0, level.valid));\n      next.max.set(level.max.subarray(0, level.valid));\n      next.last.set(level.last.subarray(0, level.valid));\n      next.valid = level.valid;\n    }\n    level = next;\n    pyramid.levels[k] = level;\n  }\n  if (level.valid >= groups) return level;\n  const prev = k > 1 ? rangeLevel(pyramid, values, n, k - 1) : null;\n  const prevCount = k > 1 ? Math.ceil(n / (size / 2)) : n;\n  const from = Math.max(0, Math.min(level.valid, groups - 1));\n  for (let g = from; g < groups; g++) {\n    const a = g * 2;\n    const b = a + 1;\n    const has = b < prevCount;\n    const minA = prev ? prev.min[a] : values[a];\n    const maxA = prev ? prev.max[a] : values[a];\n    const lastA = prev ? prev.last[a] : values[a];\n    const minB = has ? (prev ? prev.min[b] : values[b]) : NaN;\n    const maxB = has ? (prev ? prev.max[b] : values[b]) : NaN;\n    const lastB = has ? (prev ? prev.last[b] : values[b]) : NaN;\n    level.min[g] = lower(minA, minB);\n    level.max[g] = upper(maxA, maxB);\n    level.last[g] = Number.isFinite(lastB) ? lastB : lastA;\n  }\n  level.valid = n % size === 0 ? groups : groups - 1;\n  return level;\n};\n"],"mappings":"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"}

package/dist/charts/engine/trading/store.d.cts

@@ -0,0 +1,83 @@
+import { TradingBar, TradingBarsInput } from './types.cjs';
+/** OHLCV columns; only the first `length` entries are meaningful */
+export interface OhlcColumns {
+    time: Float64Array;
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+    volume: Float64Array;
+}
+export interface BarStore extends OhlcColumns {
+    length: number;
+    /** Size of the columns */
+    capacity: number;
+    /** Some bar has a volume */
+    hasVolume: boolean;
+}
+export declare const inputLength: (bars: TradingBarsInput) => number;
+export declare const createStore: () => BarStore;
+/** Replaces every bar */
+export declare const setBars: (store: BarStore, bars: TradingBarsInput) => void;
+/**
+ * Appends the bars newer than the last one (a bar at the time of the last
+ * one replaces it). Returns the index of the first changed bar, or -1.
+ */
+export declare const appendBars: (store: BarStore, bars: TradingBarsInput) => number;
+/** The `i`-th bar of an input */
+export declare const barAt: (bars: TradingBarsInput, i: number) => TradingBar;
+/**
+ * Streams a bar: replaces the last bar at the same time, appends a newer
+ * one. Returns its index; -1 (ignored) when older than the last bar.
+ */
+export declare const updateBar: (store: BarStore, bar: TradingBar) => number;
+/** Inserts the bars older than the first one; returns how many were added */
+export declare const prependBars: (store: BarStore, bars: TradingBarsInput) => number;
+/** Bar at an index as an object */
+export declare const readBar: (columns: OhlcColumns, i: number) => TradingBar;
+/** First index whose time is >= `time` (binary search) */
+export declare const lowerBoundTime: (time: Float64Array, n: number, value: number) => number;
+/**
+ * Index of the bar containing `time`: the last bar opening at or before it
+ * (0 before the first bar)
+ */
+export declare const indexOfTime: (time: Float64Array, n: number, value: number) => number;
+/** Bars aggregated `size` by `size`, aligned on index 0 */
+export interface LodLevel extends OhlcColumns {
+    size: number;
+    /** Groups up to date */
+    valid: number;
+}
+/** Aggregated levels, built lazily; level k groups 2^k bars */
+export interface Pyramid {
+    levels: (LodLevel | undefined)[];
+}
+export declare const createPyramid: () => Pyramid;
+/** Marks the groups containing bars from `from` on as stale */
+export declare const invalidatePyramid: (pyramid: Pyramid, from: number) => void;
+/**
+ * Level `k` (k >= 1) of `src` (the first `n` bars), computed from level
+ * k - 1 for the stale groups only
+ */
+export declare const pyramidLevel: (pyramid: Pyramid, src: OhlcColumns, n: number, k: number) => LodLevel;
+/** Lowest, highest and last finite value of each group of 2^k values */
+export interface RangeLevel {
+    size: number;
+    min: Float64Array;
+    max: Float64Array;
+    last: Float64Array;
+    /** Groups up to date */
+    valid: number;
+}
+/**
+ * Aggregated levels of a column of indicator values: a zoomed-out chart
+ * draws the range of each group (min / max decimation), so spikes stay
+ * visible instead of being sampled away
+ */
+export interface RangePyramid {
+    levels: (RangeLevel | undefined)[];
+}
+export declare const createRangePyramid: () => RangePyramid;
+export declare const invalidateRangePyramid: (pyramid: RangePyramid, from: number) => void;
+/** Level `k` (k >= 1) of the first `n` values, updated for the stale groups only */
+export declare const rangeLevel: (pyramid: RangePyramid, values: Float64Array, n: number, k: number) => RangeLevel;

package/dist/charts/engine/trading/store.d.ts

@@ -0,0 +1,83 @@
+import { TradingBar, TradingBarsInput } from './types.js';
+/** OHLCV columns; only the first `length` entries are meaningful */
+export interface OhlcColumns {
+    time: Float64Array;
+    open: Float64Array;
+    high: Float64Array;
+    low: Float64Array;
+    close: Float64Array;
+    volume: Float64Array;
+}
+export interface BarStore extends OhlcColumns {
+    length: number;
+    /** Size of the columns */
+    capacity: number;
+    /** Some bar has a volume */
+    hasVolume: boolean;
+}
+export declare const inputLength: (bars: TradingBarsInput) => number;
+export declare const createStore: () => BarStore;
+/** Replaces every bar */
+export declare const setBars: (store: BarStore, bars: TradingBarsInput) => void;
+/**
+ * Appends the bars newer than the last one (a bar at the time of the last
+ * one replaces it). Returns the index of the first changed bar, or -1.
+ */
+export declare const appendBars: (store: BarStore, bars: TradingBarsInput) => number;
+/** The `i`-th bar of an input */
+export declare const barAt: (bars: TradingBarsInput, i: number) => TradingBar;
+/**
+ * Streams a bar: replaces the last bar at the same time, appends a newer
+ * one. Returns its index; -1 (ignored) when older than the last bar.
+ */
+export declare const updateBar: (store: BarStore, bar: TradingBar) => number;
+/** Inserts the bars older than the first one; returns how many were added */
+export declare const prependBars: (store: BarStore, bars: TradingBarsInput) => number;
+/** Bar at an index as an object */
+export declare const readBar: (columns: OhlcColumns, i: number) => TradingBar;
+/** First index whose time is >= `time` (binary search) */
+export declare const lowerBoundTime: (time: Float64Array, n: number, value: number) => number;
+/**
+ * Index of the bar containing `time`: the last bar opening at or before it
+ * (0 before the first bar)
+ */
+export declare const indexOfTime: (time: Float64Array, n: number, value: number) => number;
+/** Bars aggregated `size` by `size`, aligned on index 0 */
+export interface LodLevel extends OhlcColumns {
+    size: number;
+    /** Groups up to date */
+    valid: number;
+}
+/** Aggregated levels, built lazily; level k groups 2^k bars */
+export interface Pyramid {
+    levels: (LodLevel | undefined)[];
+}
+export declare const createPyramid: () => Pyramid;
+/** Marks the groups containing bars from `from` on as stale */
+export declare const invalidatePyramid: (pyramid: Pyramid, from: number) => void;
+/**
+ * Level `k` (k >= 1) of `src` (the first `n` bars), computed from level
+ * k - 1 for the stale groups only
+ */
+export declare const pyramidLevel: (pyramid: Pyramid, src: OhlcColumns, n: number, k: number) => LodLevel;
+/** Lowest, highest and last finite value of each group of 2^k values */
+export interface RangeLevel {
+    size: number;
+    min: Float64Array;
+    max: Float64Array;
+    last: Float64Array;
+    /** Groups up to date */
+    valid: number;
+}
+/**
+ * Aggregated levels of a column of indicator values: a zoomed-out chart
+ * draws the range of each group (min / max decimation), so spikes stay
+ * visible instead of being sampled away
+ */
+export interface RangePyramid {
+    levels: (RangeLevel | undefined)[];
+}
+export declare const createRangePyramid: () => RangePyramid;
+export declare const invalidateRangePyramid: (pyramid: RangePyramid, from: number) => void;
+/** Level `k` (k >= 1) of the first `n` values, updated for the stale groups only */
+export declare const rangeLevel: (pyramid: RangePyramid, values: Float64Array, n: number, k: number) => RangeLevel;

package/dist/charts/engine/trading/store.js

@@ -0,0 +1,150 @@
+//#region src/engine/trading/store.ts
+var e = [
+	"time",
+	"open",
+	"high",
+	"low",
+	"close",
+	"volume"
+], t = (e) => !Array.isArray(e), n = (e) => t(e) ? Math.min(e.time.length, e.open.length, e.high.length, e.low.length, e.close.length) : e.length, r = (e) => ({
+	time: new Float64Array(e),
+	open: new Float64Array(e),
+	high: new Float64Array(e),
+	low: new Float64Array(e),
+	close: new Float64Array(e),
+	volume: new Float64Array(e)
+}), i = () => ({
+	...r(16),
+	length: 0,
+	capacity: 16,
+	hasVolume: !1
+}), a = (t, n) => {
+	if (n <= t.capacity) return;
+	let i = t.capacity;
+	for (; i < n;) i *= 2;
+	let a = r(i);
+	for (let n of e) a[n].set(t[n].subarray(0, t.length));
+	Object.assign(t, a), t.capacity = i;
+}, o = (e, n, r, i) => {
+	if (t(n)) {
+		for (let t = 0; t < i; t++) e.time[r + t] = n.time[t], e.open[r + t] = n.open[t], e.high[r + t] = n.high[t], e.low[r + t] = n.low[t], e.close[r + t] = n.close[t];
+		let t = n.volume;
+		if (t) {
+			for (let n = 0; n < i; n++) {
+				let i = t[n];
+				e.volume[r + n] = Number.isFinite(i) ? i : 0;
+			}
+			e.hasVolume = !0;
+		} else e.volume.fill(0, r, r + i);
+		return;
+	}
+	for (let t = 0; t < i; t++) s(e, r + t, n[t]);
+}, s = (e, t, n) => {
+	e.time[t] = n.time, e.open[t] = n.open, e.high[t] = n.high, e.low[t] = n.low, e.close[t] = n.close;
+	let r = n.volume;
+	r !== void 0 && Number.isFinite(r) ? (e.volume[t] = r, e.hasVolume = !0) : e.volume[t] = 0;
+}, c = (e, t) => {
+	let r = n(t);
+	e.length = 0, e.hasVolume = !1, a(e, r), o(e, t, 0, r), e.length = r;
+}, l = (e, t) => {
+	let r = n(t), i = -1;
+	for (let n = 0; n < r; n++) {
+		let r = d(e, u(t, n));
+		r >= 0 && (i < 0 || r < i) && (i = r);
+	}
+	return i;
+}, u = (e, n) => t(e) ? {
+	time: e.time[n],
+	open: e.open[n],
+	high: e.high[n],
+	low: e.low[n],
+	close: e.close[n],
+	...e.volume ? { volume: e.volume[n] } : {}
+} : e[n], d = (e, t) => {
+	let n = e.length;
+	if (!Number.isFinite(t.time)) return -1;
+	if (n > 0) {
+		let r = e.time[n - 1];
+		if (t.time < r) return -1;
+		if (t.time === r) return s(e, n - 1, t), n - 1;
+	}
+	return a(e, n + 1), s(e, n, t), e.length = n + 1, n;
+}, f = (r, i) => {
+	let s = n(i), c = r.length ? r.time[0] : Infinity, l = 0, u = t(i) ? i.time : null;
+	for (; l < s && (u ? u[l] : i[l].time) < c;) l++;
+	if (!l) return 0;
+	let d = r.length, f = {
+		time: r.time.slice(0, d),
+		open: r.open.slice(0, d),
+		high: r.high.slice(0, d),
+		low: r.low.slice(0, d),
+		close: r.close.slice(0, d),
+		volume: r.volume.slice(0, d)
+	};
+	r.length = 0, a(r, d + l), o(r, i, 0, l);
+	for (let t of e) r[t].set(f[t], l);
+	return r.length = d + l, l;
+}, p = (e, t) => ({
+	time: e.time[t],
+	open: e.open[t],
+	high: e.high[t],
+	low: e.low[t],
+	close: e.close[t],
+	volume: e.volume[t]
+}), m = (e, t, n) => {
+	let r = 0, i = t;
+	for (; r < i;) {
+		let t = r + i >>> 1;
+		e[t] < n ? r = t + 1 : i = t;
+	}
+	return r;
+}, h = (e, t, n) => {
+	let r = m(e, t, n);
+	return r < t && e[r] === n ? r : Math.max(0, r - 1);
+}, g = () => ({ levels: [] }), _ = (t, n, i, a) => {
+	let o = 2 ** a, s = Math.ceil(i / o), c = t.levels[a];
+	if (!c || c.time.length < s) {
+		let n = {
+			...r(Math.max(16, Math.ceil(s * 1.5))),
+			size: o,
+			valid: 0
+		};
+		if (c) {
+			for (let t of e) n[t].set(c[t].subarray(0, c.valid));
+			n.valid = c.valid;
+		}
+		c = n, t.levels[a] = c;
+	}
+	if (c.valid >= s) return c;
+	let l = a > 1 ? _(t, n, i, a - 1) : n, u = a > 1 ? Math.ceil(i / (o / 2)) : i, d = Math.max(0, Math.min(c.valid, s - 1));
+	for (let e = d; e < s; e++) {
+		let t = e * 2, n = t + 1;
+		c.time[e] = l.time[t], c.open[e] = l.open[t], n < u ? (c.high[e] = Math.max(l.high[t], l.high[n]), c.low[e] = Math.min(l.low[t], l.low[n]), c.close[e] = l.close[n], c.volume[e] = l.volume[t] + l.volume[n]) : (c.high[e] = l.high[t], c.low[e] = l.low[t], c.close[e] = l.close[t], c.volume[e] = l.volume[t]);
+	}
+	return c.valid = i % o === 0 ? s : s - 1, c;
+}, v = () => ({ levels: [] }), y = (e, t) => {
+	for (let n of e.levels) n && (n.valid = Math.min(n.valid, Math.floor(t / n.size)));
+}, b = (e, t) => Number.isFinite(e) ? Number.isFinite(t) ? e < t ? e : t : e : t, x = (e, t) => Number.isFinite(e) ? Number.isFinite(t) ? e > t ? e : t : e : t, S = (e, t, n, r) => {
+	let i = 2 ** r, a = Math.ceil(n / i), o = e.levels[r];
+	if (!o || o.min.length < a) {
+		let t = Math.max(16, Math.ceil(a * 1.5)), n = {
+			size: i,
+			min: new Float64Array(t),
+			max: new Float64Array(t),
+			last: new Float64Array(t),
+			valid: 0
+		};
+		o && (n.min.set(o.min.subarray(0, o.valid)), n.max.set(o.max.subarray(0, o.valid)), n.last.set(o.last.subarray(0, o.valid)), n.valid = o.valid), o = n, e.levels[r] = o;
+	}
+	if (o.valid >= a) return o;
+	let s = r > 1 ? S(e, t, n, r - 1) : null, c = r > 1 ? Math.ceil(n / (i / 2)) : n, l = Math.max(0, Math.min(o.valid, a - 1));
+	for (let e = l; e < a; e++) {
+		let n = e * 2, r = n + 1, i = r < c, a = s ? s.min[n] : t[n], l = s ? s.max[n] : t[n], u = s ? s.last[n] : t[n], d = i ? s ? s.min[r] : t[r] : NaN, f = i ? s ? s.max[r] : t[r] : NaN, p = i ? s ? s.last[r] : t[r] : NaN;
+		o.min[e] = b(a, d), o.max[e] = x(l, f), o.last[e] = Number.isFinite(p) ? p : u;
+	}
+	return o.valid = n % i === 0 ? a : a - 1, o;
+};
+//#endregion
+export { l as appendBars, u as barAt, g as createPyramid, v as createRangePyramid, i as createStore, h as indexOfTime, n as inputLength, y as invalidateRangePyramid, m as lowerBoundTime, f as prependBars, _ as pyramidLevel, S as rangeLevel, p as readBar, c as setBars, d as updateBar };
+
+//# sourceMappingURL=store.js.map

package/dist/charts/engine/trading/store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["KEYS","isColumns","bars","inputLength","allocate","capacity","createStore","reserve","size","store","next","key","write","i","count","at","volume","v","writeBar","bar","setBars","n","appendBars","first","updateBar","barAt","last","prependBars","time","length","previous","readBar","columns","lowerBoundTime","lo","hi","mid","value","indexOfTime","createPyramid","pyramidLevel","k","groups","level","pyramid","prev","src","prevCount","from","g","a","b","createRangePyramid","invalidateRangePyramid","lower","upper","rangeLevel","values","has","minA","maxA","lastA","minB","maxB","lastB"],"sources":["../../../../../charts/src/engine/trading/store.ts"],"sourcesContent":["// Bars in growable Float64Array columns, and a pyramid of aggregated\n// levels (2, 4, 8, ... bars per group) drawn when the chart is zoomed out\n// so far that a bar is narrower than a pixel: a million bars cost the\n// same to draw as a thousand.\n\nimport type { TradingBar, TradingBarColumns, TradingBarsInput } from \"./types\";\n\n/** OHLCV columns; only the first `length` entries are meaningful */\nexport interface OhlcColumns {\n  time: Float64Array;\n  open: Float64Array;\n  high: Float64Array;\n  low: Float64Array;\n  close: Float64Array;\n  volume: Float64Array;\n}\n\nexport interface BarStore extends OhlcColumns {\n  length: number;\n  /** Size of the columns */\n  capacity: number;\n  /** Some bar has a volume */\n  hasVolume: boolean;\n}\n\nconst KEYS = [\"time\", \"open\", \"high\", \"low\", \"close\", \"volume\"] as const;\n\nconst isColumns = (bars: TradingBarsInput): bars is TradingBarColumns =>\n  !Array.isArray(bars);\n\nexport const inputLength = (bars: TradingBarsInput): number =>\n  isColumns(bars)\n    ? Math.min(\n        bars.time.length,\n        bars.open.length,\n        bars.high.length,\n        bars.low.length,\n        bars.close.length,\n      )\n    : bars.length;\n\nconst allocate = (capacity: number): OhlcColumns => ({\n  time: new Float64Array(capacity),\n  open: new Float64Array(capacity),\n  high: new Float64Array(capacity),\n  low: new Float64Array(capacity),\n  close: new Float64Array(capacity),\n  volume: new Float64Array(capacity),\n});\n\nexport const createStore = (): BarStore => ({\n  ...allocate(16),\n  length: 0,\n  capacity: 16,\n  hasVolume: false,\n});\n\n/** Grows the columns to hold at least `size` bars (doubling) */\nconst reserve = (store: BarStore, size: number) => {\n  if (size <= store.capacity) return;\n  let capacity = store.capacity;\n  while (capacity < size) capacity *= 2;\n  const next = allocate(capacity);\n  for (const key of KEYS) next[key].set(store[key].subarray(0, store.length));\n  Object.assign(store, next);\n  store.capacity = capacity;\n};\n\n/** Writes `count` bars of `bars` at `at` */\nconst write = (\n  store: BarStore,\n  bars: TradingBarsInput,\n  at: number,\n  count: number,\n) => {\n  if (isColumns(bars)) {\n    for (let i = 0; i < count; i++) {\n      store.time[at + i] = bars.time[i];\n      store.open[at + i] = bars.open[i];\n      store.high[at + i] = bars.high[i];\n      store.low[at + i] = bars.low[i];\n      store.close[at + i] = bars.close[i];\n    }\n    const volume = bars.volume;\n    if (volume) {\n      for (let i = 0; i < count; i++) {\n        const v = volume[i];\n        store.volume[at + i] = Number.isFinite(v) ? v : 0;\n      }\n      store.hasVolume = true;\n    } else {\n      store.volume.fill(0, at, at + count);\n    }\n    return;\n  }\n  for (let i = 0; i < count; i++) writeBar(store, at + i, bars[i]);\n};\n\nconst writeBar = (store: BarStore, i: number, bar: TradingBar) => {\n  store.time[i] = bar.time;\n  store.open[i] = bar.open;\n  store.high[i] = bar.high;\n  store.low[i] = bar.low;\n  store.close[i] = bar.close;\n  const v = bar.volume;\n  if (v !== undefined && Number.isFinite(v)) {\n    store.volume[i] = v;\n    store.hasVolume = true;\n  } else {\n    store.volume[i] = 0;\n  }\n};\n\n/** Replaces every bar */\nexport const setBars = (store: BarStore, bars: TradingBarsInput): void => {\n  const n = inputLength(bars);\n  store.length = 0;\n  store.hasVolume = false;\n  reserve(store, n);\n  write(store, bars, 0, n);\n  store.length = n;\n};\n\n/**\n * Appends the bars newer than the last one (a bar at the time of the last\n * one replaces it). Returns the index of the first changed bar, or -1.\n */\nexport const appendBars = (store: BarStore, bars: TradingBarsInput): number => {\n  const n = inputLength(bars);\n  let first = -1;\n  for (let i = 0; i < n; i++) {\n    const at = updateBar(store, barAt(bars, i));\n    if (at >= 0 && (first < 0 || at < first)) first = at;\n  }\n  return first;\n};\n\n/** The `i`-th bar of an input */\nexport const barAt = (bars: TradingBarsInput, i: number): TradingBar => {\n  if (!isColumns(bars)) return bars[i];\n  return {\n    time: bars.time[i],\n    open: bars.open[i],\n    high: bars.high[i],\n    low: bars.low[i],\n    close: bars.close[i],\n    ...(bars.volume ? { volume: bars.volume[i] } : {}),\n  };\n};\n\n/**\n * Streams a bar: replaces the last bar at the same time, appends a newer\n * one. Returns its index; -1 (ignored) when older than the last bar.\n */\nexport const updateBar = (store: BarStore, bar: TradingBar): number => {\n  const n = store.length;\n  if (!Number.isFinite(bar.time)) return -1;\n  if (n > 0) {\n    const last = store.time[n - 1];\n    if (bar.time < last) return -1;\n    if (bar.time === last) {\n      writeBar(store, n - 1, bar);\n      return n - 1;\n    }\n  }\n  reserve(store, n + 1);\n  writeBar(store, n, bar);\n  store.length = n + 1;\n  return n;\n};\n\n/** Inserts the bars older than the first one; returns how many were added */\nexport const prependBars = (\n  store: BarStore,\n  bars: TradingBarsInput,\n): number => {\n  const n = inputLength(bars);\n  const first = store.length ? store.time[0] : Infinity;\n  // keep only the bars strictly older than the current first bar\n  let count = 0;\n  const time = isColumns(bars) ? bars.time : null;\n  while (\n    count < n &&\n    (time ? time[count] : (bars as readonly TradingBar[])[count].time) < first\n  ) {\n    count++;\n  }\n  if (!count) return 0;\n  const length = store.length;\n  const previous: OhlcColumns = {\n    time: store.time.slice(0, length),\n    open: store.open.slice(0, length),\n    high: store.high.slice(0, length),\n    low: store.low.slice(0, length),\n    close: store.close.slice(0, length),\n    volume: store.volume.slice(0, length),\n  };\n  store.length = 0;\n  reserve(store, length + count);\n  write(store, bars, 0, count);\n  for (const key of KEYS) store[key].set(previous[key], count);\n  store.length = length + count;\n  return count;\n};\n\n/** Bar at an index as an object */\nexport const readBar = (columns: OhlcColumns, i: number): TradingBar => ({\n  time: columns.time[i],\n  open: columns.open[i],\n  high: columns.high[i],\n  low: columns.low[i],\n  close: columns.close[i],\n  volume: columns.volume[i],\n});\n\n/** First index whose time is >= `time` (binary search) */\nexport const lowerBoundTime = (\n  time: Float64Array,\n  n: number,\n  value: number,\n): number => {\n  let lo = 0;\n  let hi = n;\n  while (lo < hi) {\n    const mid = (lo + hi) >>> 1;\n    if (time[mid] < value) lo = mid + 1;\n    else hi = mid;\n  }\n  return lo;\n};\n\n/**\n * Index of the bar containing `time`: the last bar opening at or before it\n * (0 before the first bar)\n */\nexport const indexOfTime = (\n  time: Float64Array,\n  n: number,\n  value: number,\n): number => {\n  const i = lowerBoundTime(time, n, value);\n  if (i < n && time[i] === value) return i;\n  return Math.max(0, i - 1);\n};\n\n// ---------------------------------------------------------------- pyramid\n\n/** Bars aggregated `size` by `size`, aligned on index 0 */\nexport interface LodLevel extends OhlcColumns {\n  size: number;\n  /** Groups up to date */\n  valid: number;\n}\n\n/** Aggregated levels, built lazily; level k groups 2^k bars */\nexport interface Pyramid {\n  levels: (LodLevel | undefined)[];\n}\n\nexport const createPyramid = (): Pyramid => ({ levels: [] });\n\n/** Marks the groups containing bars from `from` on as stale */\nexport const invalidatePyramid = (pyramid: Pyramid, from: number): void => {\n  for (const level of pyramid.levels) {\n    if (level)\n      level.valid = Math.min(level.valid, Math.floor(from / level.size));\n  }\n};\n\n/**\n * Level `k` (k >= 1) of `src` (the first `n` bars), computed from level\n * k - 1 for the stale groups only\n */\nexport const pyramidLevel = (\n  pyramid: Pyramid,\n  src: OhlcColumns,\n  n: number,\n  k: number,\n): LodLevel => {\n  const size = 2 ** k;\n  const groups = Math.ceil(n / size);\n  let level = pyramid.levels[k];\n  if (!level || level.time.length < groups) {\n    const capacity = Math.max(16, Math.ceil(groups * 1.5));\n    const next: LodLevel = { ...allocate(capacity), size, valid: 0 };\n    if (level) {\n      for (const key of KEYS)\n        next[key].set(level[key].subarray(0, level.valid));\n      next.valid = level.valid;\n    }\n    level = next;\n    pyramid.levels[k] = level;\n  }\n  if (level.valid >= groups) return level;\n  // the source of level k: level k - 1 (pairs) or the bars (k = 1)\n  const prev = k > 1 ? pyramidLevel(pyramid, src, n, k - 1) : src;\n  const prevCount = k > 1 ? Math.ceil(n / (size / 2)) : n;\n  // the last group of a level may be partial: always recompute it\n  const from = Math.max(0, Math.min(level.valid, groups - 1));\n  for (let g = from; g < groups; g++) {\n    const a = g * 2;\n    const b = a + 1;\n    level.time[g] = prev.time[a];\n    level.open[g] = prev.open[a];\n    if (b < prevCount) {\n      level.high[g] = Math.max(prev.high[a], prev.high[b]);\n      level.low[g] = Math.min(prev.low[a], prev.low[b]);\n      level.close[g] = prev.close[b];\n      level.volume[g] = prev.volume[a] + prev.volume[b];\n    } else {\n      level.high[g] = prev.high[a];\n      level.low[g] = prev.low[a];\n      level.close[g] = prev.close[a];\n      level.volume[g] = prev.volume[a];\n    }\n  }\n  // complete groups stay valid; the partial last one is redone next time\n  level.valid = n % size === 0 ? groups : groups - 1;\n  return level;\n};\n\n// ---------------------------------------------------------- value ranges\n\n/** Lowest, highest and last finite value of each group of 2^k values */\nexport interface RangeLevel {\n  size: number;\n  min: Float64Array;\n  max: Float64Array;\n  last: Float64Array;\n  /** Groups up to date */\n  valid: number;\n}\n\n/**\n * Aggregated levels of a column of indicator values: a zoomed-out chart\n * draws the range of each group (min / max decimation), so spikes stay\n * visible instead of being sampled away\n */\nexport interface RangePyramid {\n  levels: (RangeLevel | undefined)[];\n}\n\nexport const createRangePyramid = (): RangePyramid => ({ levels: [] });\n\nexport const invalidateRangePyramid = (\n  pyramid: RangePyramid,\n  from: number,\n): void => {\n  for (const level of pyramid.levels) {\n    if (level)\n      level.valid = Math.min(level.valid, Math.floor(from / level.size));\n  }\n};\n\nconst lower = (a: number, b: number) =>\n  !Number.isFinite(a) ? b : !Number.isFinite(b) ? a : a < b ? a : b;\nconst upper = (a: number, b: number) =>\n  !Number.isFinite(a) ? b : !Number.isFinite(b) ? a : a > b ? a : b;\n\n/** Level `k` (k >= 1) of the first `n` values, updated for the stale groups only */\nexport const rangeLevel = (\n  pyramid: RangePyramid,\n  values: Float64Array,\n  n: number,\n  k: number,\n): RangeLevel => {\n  const size = 2 ** k;\n  const groups = Math.ceil(n / size);\n  let level = pyramid.levels[k];\n  if (!level || level.min.length < groups) {\n    const capacity = Math.max(16, Math.ceil(groups * 1.5));\n    const next: RangeLevel = {\n      size,\n      min: new Float64Array(capacity),\n      max: new Float64Array(capacity),\n      last: new Float64Array(capacity),\n      valid: 0,\n    };\n    if (level) {\n      next.min.set(level.min.subarray(0, level.valid));\n      next.max.set(level.max.subarray(0, level.valid));\n      next.last.set(level.last.subarray(0, level.valid));\n      next.valid = level.valid;\n    }\n    level = next;\n    pyramid.levels[k] = level;\n  }\n  if (level.valid >= groups) return level;\n  const prev = k > 1 ? rangeLevel(pyramid, values, n, k - 1) : null;\n  const prevCount = k > 1 ? Math.ceil(n / (size / 2)) : n;\n  const from = Math.max(0, Math.min(level.valid, groups - 1));\n  for (let g = from; g < groups; g++) {\n    const a = g * 2;\n    const b = a + 1;\n    const has = b < prevCount;\n    const minA = prev ? prev.min[a] : values[a];\n    const maxA = prev ? prev.max[a] : values[a];\n    const lastA = prev ? prev.last[a] : values[a];\n    const minB = has ? (prev ? prev.min[b] : values[b]) : NaN;\n    const maxB = has ? (prev ? prev.max[b] : values[b]) : NaN;\n    const lastB = has ? (prev ? prev.last[b] : values[b]) : NaN;\n    level.min[g] = lower(minA, minB);\n    level.max[g] = upper(maxA, maxB);\n    level.last[g] = Number.isFinite(lastB) ? lastB : lastA;\n  }\n  level.valid = n % size === 0 ? groups : groups - 1;\n  return level;\n};\n"],"mappings":"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"}

package/dist/charts/engine/trading/studies.cjs

@@ -0,0 +1,2 @@
+const e=require("./indicators.cjs");var t=[`#f59e0b`,`#a855f7`,`#0ea5e9`,`#ec4899`,`#14b8a6`,`#6366f1`,`#84cc16`],n=`#a855f7`,r=`#0ea5e9`,i=`#f59e0b`,a=`#14b8a6`,o=`#6366f1`,s=`#ec4899`,c=`#2962ff`,l=e=>{switch(e.type){case`ma`:case`ema`:case`wma`:return`${e.type}:${e.period}${e.source&&e.source!==`close`?`:${e.source}`:``}`;case`boll`:return`boll:${e.period??20}:${e.multiplier??2}`;case`vwap`:return`vwap:${e.reset??`day`}`;case`volume`:return`volume`;case`macd`:return`macd:${e.fast??12}:${e.slow??26}:${e.signal??9}`;case`rsi`:return`rsi:${e.period??14}`;case`kdj`:return`kdj:${e.period??9}:${e.kPeriod??3}:${e.dPeriod??3}`;case`psar`:return`psar:${e.start??.02}:${e.increment??e.start??.02}:${e.maximum??.2}`;case`ichimoku`:return`ichimoku:${e.conversionPeriod??9}:${e.basePeriod??26}:${e.spanBPeriod??52}:${e.displacement??26}`;case`supertrend`:return`supertrend:${e.period??10}:${e.multiplier??3}`;case`keltner`:return`keltner:${e.period??20}:${e.multiplier??2}:${e.atrPeriod??10}`;case`donchian`:return`donchian:${e.period??20}`;case`obv`:return`obv`;case`cci`:return`cci:${e.period??20}`;case`stochRsi`:return`stochRsi:${e.rsiPeriod??14}:${e.stochPeriod??14}:${e.kPeriod??3}:${e.dPeriod??3}`;case`dmi`:return`dmi:${e.period??14}:${e.adxPeriod??14}`;case`williamsR`:return`williamsR:${e.period??14}`;case`mfi`:return`mfi:${e.period??14}`;default:return`atr:${e.period??14}`}},u=(e,t,n,r)=>{let{open:i,high:a,low:o,close:s}=e;for(let c=r;c<e.length;c++)switch(t){case`open`:n[c]=i[c];break;case`high`:n[c]=a[c];break;case`low`:n[c]=o[c];break;case`hl2`:n[c]=(a[c]+o[c])/2;break;case`hlc3`:n[c]=(a[c]+o[c]+s[c])/3;break;case`ohlc4`:n[c]=(i[c]+a[c]+o[c]+s[c])/4;break;default:n[c]=s[c]}},d=()=>{let e=new Map;return(t,n)=>{let r=e.get(t);if(r&&r.length>=n)return r;let i=new Float64Array(n).fill(NaN);return r&&i.set(r),e.set(t,i),i}},f=(e,t,n=`line`,r=1.5,i=0,a=1)=>({label:e,values:new Float64Array,color:t,kind:n,width:r,shift:i,alpha:a}),p=(l,p,m,h)=>{let g=d(),_=`height`in l&&l.height?l.height:110,v={id:p,type:l.type,config:l,height:_,compact:!1,fills:[]},y=(e,t,n)=>{e.outputs.forEach((e,r)=>{e.values=g(n[r]??`out${r}`,t.capacity)})};switch(l.type){case`ma`:case`ema`:case`wma`:{let n=Math.max(1,Math.floor(l.period)||1),r=l.source??`close`,i=`${l.type.toUpperCase()}${n}`,a=l.type===`ma`?e.smaInto:l.type===`ema`?e.emaInto:e.wmaInto,o={...v,overlay:!0,title:i,outputs:[f(i,l.color??t[m%t.length],`line`,l.lineWidth??1.5)],compute(e,t){y(o,e,[`value`]);let i=e.close;r!==`close`&&(i=g(`src`,e.capacity),u(e,r,i,t)),a(i,e.length,n,o.outputs[0].values,t)}};return o}case`boll`:{let t=l.period??20,n=l.multiplier??2,[a,o,s]=l.colors??[i,r,r],c={...v,overlay:!0,title:`BOLL ${t} ${n}`,plainLegend:!0,outputs:[f(`MID`,a??i,`line`,1.25),f(`UB`,o??r,`line`,1.25),f(`LB`,s??o??r,`line`,1.25)],fills:l.fill===!1?[]:[{a:1,b:2,color:o??r,opacity:.07}],compute(r,i){y(c,r,[`mid`,`up`,`low`]);let a=g(`dev`,r.capacity),[o,s,l]=c.outputs.map(e=>e.values);e.smaInto(r.close,r.length,t,o,i),e.stdevInto(r.close,r.length,t,a,i);for(let e=i;e<r.length;e++)s[e]=o[e]+n*a[e],l[e]=o[e]-n*a[e]}};return c}case`vwap`:{let t=l.reset??`day`,n={...v,overlay:!0,title:`VWAP`,outputs:[f(`VWAP`,l.color??`#ec4899`,`line`,1.5)],compute(r,i){y(n,r,[`value`]),e.vwapInto(r.high,r.low,r.close,r.volume,r.time,r.length,t,h,n.outputs[0].values,g(`pv`,r.capacity),g(`vol`,r.capacity),i)}};return n}case`volume`:{let t=l.maPeriod,n=[f(`VOL`,``,`volume`)];t&&n.push(f(`MA${t}`,r,`line`,1.25));let i={...v,overlay:!!l.overlay,compact:!0,title:`VOL`,outputs:n,compute(n,r){y(i,n,[`vol`,`ma`]);let a=i.outputs[0].values;a.set(n.volume.subarray(r,n.length),r),t&&e.smaInto(a,n.length,t,i.outputs[1].values,r)}};return i}case`macd`:{let t=l.fast??12,n=l.slow??26,a=l.signal??9,[o,s]=l.colors??[r,i],c={...v,overlay:!1,title:`MACD ${t} ${n} ${a}`,bands:[0],zero:!0,outputs:[f(`MACD`,``,`histogram`),f(`DIF`,o??r,`line`,1.25),f(`DEA`,s??i,`line`,1.25)],compute(r,i){y(c,r,[`hist`,`dif`,`dea`]);let o=r.length,s=g(`fast`,r.capacity),l=g(`slow`,r.capacity),[u,d,f]=c.outputs.map(e=>e.values);e.emaInto(r.close,o,t,s,i),e.emaInto(r.close,o,n,l,i);for(let e=i;e<o;e++)d[e]=s[e]-l[e];e.emaInto(d,o,a,f,i);for(let e=i;e<o;e++)u[e]=d[e]-f[e]}};return c}case`rsi`:{let t=l.period??14,r={...v,overlay:!1,title:`RSI ${t}`,range:[0,100],bands:[l.oversold??30,l.overbought??70],bandFill:!0,outputs:[f(`RSI${t}`,l.color??n,`line`,1.5)],compute(n,i){y(r,n,[`value`]),e.rsiInto(n.close,n.length,t,r.outputs[0].values,g(`gain`,n.capacity),g(`loss`,n.capacity),i)}};return r}case`kdj`:{let t=l.period??9,a=l.kPeriod??3,o=l.dPeriod??3,[s,c,u]=l.colors??[i,r,n],d={...v,overlay:!1,title:`KDJ ${t} ${a} ${o}`,bands:[20,80],outputs:[f(`K`,s??i,`line`,1.25),f(`D`,c??r,`line`,1.25),f(`J`,u??n,`line`,1.25)],compute(n,r){y(d,n,[`k`,`d`,`j`]);let[i,s,c]=d.outputs.map(e=>e.values);e.kdjInto(n.high,n.low,n.close,n.length,t,a,o,i,s,c,r)}};return d}case`psar`:{let t=l.start??.02,n=l.increment??t,r=l.maximum??.2,i={...v,overlay:!0,title:`SAR ${t} ${n} ${r}`,outputs:[f(`SAR`,l.color??``,`dots`,1.5)],compute(a,o){y(i,a,[`value`]),e.psarInto(a.high,a.low,a.length,t,n,r,i.outputs[0].values,{ep:g(`ep`,a.capacity),af:g(`af`,a.capacity),trend:g(`trend`,a.capacity)},o)}};return i}case`ichimoku`:{let t=l.conversionPeriod??9,n=l.basePeriod??26,r=l.spanBPeriod??52,i=Math.max(1,Math.floor(l.displacement??26))-1,[a,o,s,u,d]=l.colors??[],p={...v,overlay:!0,title:`${t} ${n} ${r} ${i+1}`,titleKey:`ichimoku`,plainLegend:!0,outputs:[f(`CONV`,a??c,`line`,1.25),f(`BASE`,o??`#e65100`,`line`,1.25),f(`LAG`,s??`#43a047`,`line`,1.25,-i),f(`A`,u??`up`,`line`,1,i,.55),f(`B`,d??`down`,`line`,1,i,.55)],fills:l.cloud===!1?[]:[{a:3,b:4,color:u??`up`,colorBelow:d??`down`,opacity:.12}],compute(i,a){y(p,i,[`conv`,`base`,`lag`,`a`,`b`]);let[o,s,c,l,u]=p.outputs.map(e=>e.values);e.ichimokuInto(i.high,i.low,i.length,t,n,r,o,s,l,u,{highest:g(`highest`,i.capacity),lowest:g(`lowest`,i.capacity)},a),c.set(i.close.subarray(a,i.length),a)}};return p}case`supertrend`:{let t=l.period??10,n=l.multiplier??3,r={...v,overlay:!0,title:`${t} ${n}`,titleKey:`supertrend`,mergeLegend:!0,outputs:[f(`UP`,l.upColor??`up`,`line`,2),f(`DOWN`,l.downColor??`down`,`line`,2)],compute(i,a){y(r,i,[`up`,`down`]);let o=g(`value`,i.capacity),s=g(`direction`,i.capacity);e.supertrendInto(i.high,i.low,i.close,i.length,t,n,o,s,{tr:g(`tr`,i.capacity),atr:g(`atr`,i.capacity),upper:g(`upper`,i.capacity),lower:g(`lower`,i.capacity)},a);let[c,l]=r.outputs.map(e=>e.values);for(let e=a;e<i.length;e++)c[e]=s[e]===1?o[e]:NaN,l[e]=s[e]===-1?o[e]:NaN}};return r}case`keltner`:case`donchian`:{let t=l.type===`keltner`,n=l.period??20,r=t?l.multiplier??2:0,s=t?l.atrPeriod??10:0,c=t?a:o,[u,d,p]=l.colors??[i,c,c],m={...v,overlay:!0,title:t?`KC ${n} ${r} ${s}`:`DC ${n}`,plainLegend:!0,outputs:[f(`MID`,u??i,`line`,1.25),f(`UB`,d??c,`line`,1.25),f(`LB`,p??d??c,`line`,1.25)],fills:l.fill===!1?[]:[{a:1,b:2,color:d??c,opacity:.07}],compute(i,a){y(m,i,[`mid`,`up`,`low`]);let[o,c,l]=m.outputs.map(e=>e.values);t?e.keltnerInto(i.high,i.low,i.close,i.length,n,r,s,o,c,l,{tr:g(`tr`,i.capacity),atr:g(`atr`,i.capacity)},a):e.donchianInto(i.high,i.low,i.length,n,c,l,o,a)}};return m}case`obv`:{let t=l.maPeriod,n=[f(`OBV`,l.color??r,`line`,1.5)];t&&n.push(f(`MA${t}`,i,`line`,1.25));let a={...v,overlay:!1,compact:!0,title:`OBV`,outputs:n,compute(n,r){y(a,n,[`obv`,`ma`]);let i=a.outputs[0].values;e.obvInto(n.close,n.volume,n.length,i,r),t&&e.smaInto(i,n.length,t,a.outputs[1].values,r)}};return a}case`cci`:{let t=l.period??20,n={...v,overlay:!1,title:`CCI ${t}`,bands:[-100,100],bandFill:!0,outputs:[f(`CCI${t}`,l.color??a,`line`,1.5)],compute(r,i){y(n,r,[`value`]),e.cciInto(r.high,r.low,r.close,r.length,t,n.outputs[0].values,g(`typical`,r.capacity),g(`mean`,r.capacity),i)}};return n}case`stochRsi`:{let t=l.rsiPeriod??14,n=l.stochPeriod??14,a=l.kPeriod??3,o=l.dPeriod??3,[s,c]=l.colors??[r,i],u={...v,overlay:!1,title:`Stoch RSI ${t} ${n} ${a} ${o}`,range:[0,100],bands:[20,80],bandFill:!0,outputs:[f(`K`,s??r,`line`,1.25),f(`D`,c??i,`line`,1.25)],compute(r,i){y(u,r,[`k`,`d`]);let[s,c]=u.outputs.map(e=>e.values);e.stochRsiInto(r.close,r.length,t,n,a,o,s,c,{rsi:g(`rsi`,r.capacity),gain:g(`gain`,r.capacity),loss:g(`loss`,r.capacity),highest:g(`highest`,r.capacity),lowest:g(`lowest`,r.capacity),raw:g(`raw`,r.capacity)},i)}};return u}case`dmi`:{let t=l.period??14,n=l.adxPeriod??14,[r,a,o]=l.colors??[`up`,`down`,i],s={...v,overlay:!1,title:`DMI ${t} ${n}`,bands:[25],outputs:[f(`+DI`,r??`up`,`line`,1.25),f(`−DI`,a??`down`,`line`,1.25),f(`ADX`,o??i,`line`,1.75)],compute(r,i){y(s,r,[`plus`,`minus`,`adx`]);let[a,o,c]=s.outputs.map(e=>e.values);e.dmiInto(r.high,r.low,r.close,r.length,t,n,a,o,c,{tr:g(`tr`,r.capacity),plusDm:g(`plusDm`,r.capacity),minusDm:g(`minusDm`,r.capacity),smoothTr:g(`smoothTr`,r.capacity),smoothPlus:g(`smoothPlus`,r.capacity),smoothMinus:g(`smoothMinus`,r.capacity),dx:g(`dx`,r.capacity)},i)}};return s}case`williamsR`:{let t=l.period??14,r={...v,overlay:!1,title:`%R ${t}`,range:[-100,0],bands:[-80,-20],bandFill:!0,outputs:[f(`%R${t}`,l.color??n,`line`,1.5)],compute(n,i){y(r,n,[`value`]),e.williamsRInto(n.high,n.low,n.close,n.length,t,r.outputs[0].values,g(`highest`,n.capacity),g(`lowest`,n.capacity),i)}};return r}case`mfi`:{let t=l.period??14,n={...v,overlay:!1,title:`MFI ${t}`,range:[0,100],bands:[20,80],bandFill:!0,outputs:[f(`MFI${t}`,l.color??s,`line`,1.5)],compute(r,i){y(n,r,[`value`]),e.mfiInto(r.high,r.low,r.close,r.volume,r.length,t,n.outputs[0].values,g(`typical`,r.capacity),i)}};return n}default:{let t=l.period??14,n={...v,overlay:!1,title:`ATR ${t}`,outputs:[f(`ATR${t}`,l.color??r,`line`,1.5)],compute(r,i){y(n,r,[`value`]);let a=g(`tr`,r.capacity);e.trueRangeInto(r.high,r.low,r.close,r.length,a,i),e.rmaInto(a,r.length,t,n.outputs[0].values,i)}};return n}}},m=(e,t,n)=>{let r=new Set,i=new Set,a=0;return{studies:e.map(e=>{let o=e.id??l(e);for(let t=2;r.has(o);t++)o=`${e.id??l(e)}#${t}`;r.add(o);let s=e.type===`ma`||e.type===`ema`||e.type===`wma`?a++:0,c=t.find(e=>e.id===o);return c&&h(c.config,e)?(c.config=e,i.add(c),c):p(e,o,s,n)}),reused:i}},h=(e,t)=>{if(e===t)return!0;let n=new Set([...Object.keys(e),...Object.keys(t)]);n.delete(`visible`);for(let r of n){let n=e[r],i=t[r];if(n!==i&&!(Array.isArray(n)&&Array.isArray(i)&&n.join()===i.join()))return!1}return!0};exports.LINE_COLORS=t,exports.buildStudies=m,exports.createStudy=p,exports.indicatorKey=l;
+//# sourceMappingURL=studies.cjs.map