@363045841yyt/klinechart-core 0.8.12 → 0.8.13-alpha.0

package/src/components/volumeProfile/createVolumeProfileController.ts

@@ -29,16 +29,16 @@ import { binBarToBuckets } from './binning'
 import { findPOCIndex } from './poc'
 import { computeValueArea } from './valueArea'
 import type {
-    VolumeProfileBar,
-    VolumeProfileConfig,
-    VolumeProfileController,
-    VolumeProfileState,
+  VolumeProfileBar,
+  VolumeProfileConfig,
+  VolumeProfileController,
+  VolumeProfileState,
 } from './types'
 
 const DEFAULT_CONFIG: VolumeProfileConfig = {
-    binCount: 100,
-    binningMode: 'typical-price',
-    valueAreaPercent: 0.7,
+  binCount: 100,
+  binningMode: 'typical-price',
+  valueAreaPercent: 0.7,
 }
 
 // Smallest binSize we will use. Prevents a degenerate "all bars same price"
@@ -47,167 +47,154 @@ const DEFAULT_CONFIG: VolumeProfileConfig = {
 const MIN_BIN_SIZE = 1e-12
 
 export interface VolumeProfileControllerInit {
-    config?: Partial<VolumeProfileConfig>
+  config?: Partial<VolumeProfileConfig>
 }
 
 export function createVolumeProfileController(
-    init?: VolumeProfileControllerInit,
+  init?: VolumeProfileControllerInit,
 ): VolumeProfileController {
-    // -------------------------------------------------------------------
-    // Signals
-    // -------------------------------------------------------------------
-    const initialConfig: VolumeProfileConfig = {
-        ...DEFAULT_CONFIG,
-        ...(init?.config ?? {}),
-    }
-    // Defensive clamp: percent in [0, 1], binCount >= 1.
-    if (initialConfig.valueAreaPercent < 0) initialConfig.valueAreaPercent = 0
-    if (initialConfig.valueAreaPercent > 1) initialConfig.valueAreaPercent = 1
-    if (initialConfig.binCount < 1) initialConfig.binCount = 1
-
-    const config: Signal<VolumeProfileConfig> = createSignal(initialConfig)
-    const state: Signal<VolumeProfileState | null> =
-        createSignal<VolumeProfileState | null>(null)
-
-    // -------------------------------------------------------------------
-    // ingest — full recompute
-    // -------------------------------------------------------------------
-    function ingest(bars: ReadonlyArray<VolumeProfileBar>): void {
-        const cfg = config.peek()
-
-        if (bars.length === 0) {
-            state.set(null)
-            return
-        }
-
-        // First pass: range of the data.
-        let minLow = Infinity
-        let maxHigh = -Infinity
-        for (let i = 0; i < bars.length; i++) {
-            const b = bars[i]
-            if (b === undefined) continue
-            if (b.low < minLow) minLow = b.low
-            if (b.high > maxHigh) maxHigh = b.high
-        }
-
-        if (!Number.isFinite(minLow) || !Number.isFinite(maxHigh)) {
-            state.set(null)
-            return
-        }
-
-        const range = maxHigh - minLow
-        // Degenerate range: every bar at the same price. We still want a
-        // non-zero binSize so the math works; centre a tiny window on the
-        // price so the single bucket captures everything.
-        const binSize =
-            range > MIN_BIN_SIZE ? range / cfg.binCount : MIN_BIN_SIZE
-        const binMin = minLow
-
-        // Allocate or reuse the buckets. Reuse only if the size matches —
-        // changing `binCount` via `setConfig` requires a fresh array.
-        const prev = state.peek()
-        const buckets =
-            prev !== null && prev.buckets.length === cfg.binCount
-                ? prev.buckets
-                : new Float64Array(cfg.binCount)
-        // Zero it (whether reused or freshly allocated) — `fill(0)` is cheap
-        // on typed arrays.
-        buckets.fill(0)
-
-        // Second pass: drop volume into buckets.
-        for (let i = 0; i < bars.length; i++) {
-            const b = bars[i]
-            if (b === undefined) continue
-            binBarToBuckets(
-                b,
-                buckets,
-                binMin,
-                binSize,
-                cfg.binCount,
-                cfg.binningMode,
-            )
-        }
-
-        // POC + VA.
-        const pocIdx = findPOCIndex(buckets)
-        // findPOCIndex returns -1 only on empty arrays — guarded above.
-        const va = computeValueArea(
-            buckets,
-            pocIdx < 0 ? 0 : pocIdx,
-            cfg.valueAreaPercent,
-        )
-
-        // Prices: each bucket spans `[binMin + i*binSize, binMin + (i+1)*binSize)`.
-        // We report POC as the bucket *center*, VAH as the upper bucket's high
-        // edge, VAL as the lower bucket's low edge — this matches how a
-        // renderer wants to draw them: POC as a centerline, VAH/VAL as
-        // envelope edges.
-        const pocPrice = binMin + (va.pocIndex + 0.5) * binSize
-        const vahPrice = binMin + (va.vahIndex + 1) * binSize
-        const valPrice = binMin + va.valIndex * binSize
-
-        const next: VolumeProfileState = {
-            buckets,
-            binMin,
-            binSize,
-            poc: pocPrice,
-            vah: vahPrice,
-            val: valPrice,
-            totalVolume: va.totalVolume,
-            vaVolume: va.vaVolume,
-        }
-        state.set(next)
+  // -------------------------------------------------------------------
+  // Signals
+  // -------------------------------------------------------------------
+  const initialConfig: VolumeProfileConfig = {
+    ...DEFAULT_CONFIG,
+    ...(init?.config ?? {}),
+  }
+  // Defensive clamp: percent in [0, 1], binCount >= 1.
+  if (initialConfig.valueAreaPercent < 0) initialConfig.valueAreaPercent = 0
+  if (initialConfig.valueAreaPercent > 1) initialConfig.valueAreaPercent = 1
+  if (initialConfig.binCount < 1) initialConfig.binCount = 1
+
+  const config: Signal<VolumeProfileConfig> = createSignal(initialConfig)
+  const state: Signal<VolumeProfileState | null> = createSignal<VolumeProfileState | null>(null)
+
+  // -------------------------------------------------------------------
+  // ingest — full recompute
+  // -------------------------------------------------------------------
+  function ingest(bars: ReadonlyArray<VolumeProfileBar>): void {
+    const cfg = config.peek()
+
+    if (bars.length === 0) {
+      state.set(null)
+      return
     }
 
-    // -------------------------------------------------------------------
-    // setConfig — patch + invalidate
-    // -------------------------------------------------------------------
-    function setConfig(next: Partial<VolumeProfileConfig>): void {
-        const cur = config.peek()
-        const merged: VolumeProfileConfig = { ...cur, ...next }
-        // Re-apply the defensive clamps.
-        if (merged.valueAreaPercent < 0) merged.valueAreaPercent = 0
-        if (merged.valueAreaPercent > 1) merged.valueAreaPercent = 1
-        if (merged.binCount < 1) merged.binCount = 1
-
-        // If binCount changed, the existing buckets are stale (different
-        // resolution) — clear state so callers know to re-ingest. Other
-        // field changes leave the data untouched until next ingest.
-        if (merged.binCount !== cur.binCount) {
-            state.set(null)
-        }
-        config.set(merged)
+    // First pass: range of the data.
+    let minLow = Infinity
+    let maxHigh = -Infinity
+    for (let i = 0; i < bars.length; i++) {
+      const b = bars[i]
+      if (b === undefined) continue
+      if (b.low < minLow) minLow = b.low
+      if (b.high > maxHigh) maxHigh = b.high
     }
 
-    // -------------------------------------------------------------------
-    // reset — clear state, keep config
-    // -------------------------------------------------------------------
-    function reset(): void {
-        state.set(null)
+    if (!Number.isFinite(minLow) || !Number.isFinite(maxHigh)) {
+      state.set(null)
+      return
     }
 
-    // -------------------------------------------------------------------
-    // dispose — silence mutators (same pattern as IndicatorSelectorController)
-    // -------------------------------------------------------------------
-    let disposed = false
-    function dispose(): void {
-        if (disposed) return
-        disposed = true
+    const range = maxHigh - minLow
+    // Degenerate range: every bar at the same price. We still want a
+    // non-zero binSize so the math works; centre a tiny window on the
+    // price so the single bucket captures everything.
+    const binSize = range > MIN_BIN_SIZE ? range / cfg.binCount : MIN_BIN_SIZE
+    const binMin = minLow
+
+    // Allocate or reuse the buckets. Reuse only if the size matches —
+    // changing `binCount` via `setConfig` requires a fresh array.
+    const prev = state.peek()
+    const buckets =
+      prev !== null && prev.buckets.length === cfg.binCount
+        ? prev.buckets
+        : new Float64Array(cfg.binCount)
+    // Zero it (whether reused or freshly allocated) — `fill(0)` is cheap
+    // on typed arrays.
+    buckets.fill(0)
+
+    // Second pass: drop volume into buckets.
+    for (let i = 0; i < bars.length; i++) {
+      const b = bars[i]
+      if (b === undefined) continue
+      binBarToBuckets(b, buckets, binMin, binSize, cfg.binCount, cfg.binningMode)
     }
 
-    function guard<T extends (...args: never[]) => unknown>(fn: T): T {
-        return ((...args: Parameters<T>): ReturnType<T> => {
-            if (disposed) return undefined as ReturnType<T>
-            return fn(...args) as ReturnType<T>
-        }) as T
+    // POC + VA.
+    const pocIdx = findPOCIndex(buckets)
+    // findPOCIndex returns -1 only on empty arrays — guarded above.
+    const va = computeValueArea(buckets, pocIdx < 0 ? 0 : pocIdx, cfg.valueAreaPercent)
+
+    // Prices: each bucket spans `[binMin + i*binSize, binMin + (i+1)*binSize)`.
+    // We report POC as the bucket *center*, VAH as the upper bucket's high
+    // edge, VAL as the lower bucket's low edge — this matches how a
+    // renderer wants to draw them: POC as a centerline, VAH/VAL as
+    // envelope edges.
+    const pocPrice = binMin + (va.pocIndex + 0.5) * binSize
+    const vahPrice = binMin + (va.vahIndex + 1) * binSize
+    const valPrice = binMin + va.valIndex * binSize
+
+    const next: VolumeProfileState = {
+      buckets,
+      binMin,
+      binSize,
+      poc: pocPrice,
+      vah: vahPrice,
+      val: valPrice,
+      totalVolume: va.totalVolume,
+      vaVolume: va.vaVolume,
     }
-
-    return {
-        config,
-        state,
-        ingest: guard(ingest),
-        setConfig: guard(setConfig),
-        reset: guard(reset),
-        dispose,
+    state.set(next)
+  }
+
+  // -------------------------------------------------------------------
+  // setConfig — patch + invalidate
+  // -------------------------------------------------------------------
+  function setConfig(next: Partial<VolumeProfileConfig>): void {
+    const cur = config.peek()
+    const merged: VolumeProfileConfig = { ...cur, ...next }
+    // Re-apply the defensive clamps.
+    if (merged.valueAreaPercent < 0) merged.valueAreaPercent = 0
+    if (merged.valueAreaPercent > 1) merged.valueAreaPercent = 1
+    if (merged.binCount < 1) merged.binCount = 1
+
+    // If binCount changed, the existing buckets are stale (different
+    // resolution) — clear state so callers know to re-ingest. Other
+    // field changes leave the data untouched until next ingest.
+    if (merged.binCount !== cur.binCount) {
+      state.set(null)
     }
+    config.set(merged)
+  }
+
+  // -------------------------------------------------------------------
+  // reset — clear state, keep config
+  // -------------------------------------------------------------------
+  function reset(): void {
+    state.set(null)
+  }
+
+  // -------------------------------------------------------------------
+  // dispose — silence mutators (same pattern as IndicatorSelectorController)
+  // -------------------------------------------------------------------
+  let disposed = false
+  function dispose(): void {
+    if (disposed) return
+    disposed = true
+  }
+
+  function guard<T extends (...args: never[]) => unknown>(fn: T): T {
+    return ((...args: Parameters<T>): ReturnType<T> => {
+      if (disposed) return undefined as ReturnType<T>
+      return fn(...args) as ReturnType<T>
+    }) as T
+  }
+
+  return {
+    config,
+    state,
+    ingest: guard(ingest),
+    setConfig: guard(setConfig),
+    reset: guard(reset),
+    dispose,
+  }
 }

package/src/components/volumeProfile/index.ts

@@ -1,10 +1,10 @@
 export type {
-    BinningMode,
-    VolumeProfileConfig,
-    VolumeProfileState,
-    VolumeProfileBar,
-    VolumeProfileController,
-    ValueAreaResult,
+  BinningMode,
+  VolumeProfileConfig,
+  VolumeProfileState,
+  VolumeProfileBar,
+  VolumeProfileController,
+  ValueAreaResult,
 } from './types'
 export { binBarToBuckets } from './binning'
 export { findPOCIndex } from './poc'

package/src/components/volumeProfile/poc.ts

@@ -33,21 +33,21 @@
  *   Closes API audit BLOCKER-002 (export * leakage taxonomy).
  */
 export function findPOCIndex(buckets: Float64Array): number {
-    const n = buckets.length
-    if (n === 0) return -1
+  const n = buckets.length
+  if (n === 0) return -1
 
-    let bestIdx = 0
-    let bestVol = buckets[0] ?? 0
+  let bestIdx = 0
+  let bestVol = buckets[0] ?? 0
 
-    // Walk buckets[1..]; strictly-greater wins, equal does NOT (keeps the
-    // earliest index — the documented tie-breaker).
-    for (let i = 1; i < n; i++) {
-        const v = buckets[i] ?? 0
-        if (v > bestVol) {
-            bestVol = v
-            bestIdx = i
-        }
+  // Walk buckets[1..]; strictly-greater wins, equal does NOT (keeps the
+  // earliest index — the documented tie-breaker).
+  for (let i = 1; i < n; i++) {
+    const v = buckets[i] ?? 0
+    if (v > bestVol) {
+      bestVol = v
+      bestIdx = i
     }
+  }
 
-    return bestIdx
+  return bestIdx
 }

package/src/components/volumeProfile/types.ts

@@ -39,16 +39,16 @@ export type BinningMode = 'typical-price' | 'proportional'
  * from sensible defaults so callers can pass `{}`.
  */
 export interface VolumeProfileConfig {
-    /** Number of price buckets (histogram resolution). Typical 50–200. */
-    binCount: number
-    /** Per-bar binning strategy. See `BinningMode`. */
-    binningMode: BinningMode
-    /**
-     * Fraction of total volume that must be inside the Value Area, in [0, 1].
-     * CME convention is 0.70. Set 1.0 to use the full range, set to e.g. 0.95
-     * for institution-style "value extended" envelopes.
-     */
-    valueAreaPercent: number
+  /** Number of price buckets (histogram resolution). Typical 50–200. */
+  binCount: number
+  /** Per-bar binning strategy. See `BinningMode`. */
+  binningMode: BinningMode
+  /**
+   * Fraction of total volume that must be inside the Value Area, in [0, 1].
+   * CME convention is 0.70. Set 1.0 to use the full range, set to e.g. 0.95
+   * for institution-style "value extended" envelopes.
+   */
+  valueAreaPercent: number
 }
 
 /**
@@ -61,22 +61,22 @@ export interface VolumeProfileConfig {
  * storage buffer once the WebGPU compute path lands (see `computeShader.wgsl.md`).
  */
 export interface VolumeProfileState {
-    /** Histogram. `buckets[i]` is the total volume in bucket i. */
-    buckets: Float64Array
-    /** Low-edge price of bucket 0. */
-    binMin: number
-    /** Price width of one bucket. `buckets.length * binSize = total price span`. */
-    binSize: number
-    /** Point of Control — center price of the highest-volume bucket. */
-    poc: number
-    /** Value Area High — upper edge price of the VAH bucket. */
-    vah: number
-    /** Value Area Low — lower edge price of the VAL bucket. */
-    val: number
-    /** Sum of every bucket. */
-    totalVolume: number
-    /** Volume inside the closed Value Area `[valIndex, vahIndex]`. */
-    vaVolume: number
+  /** Histogram. `buckets[i]` is the total volume in bucket i. */
+  buckets: Float64Array
+  /** Low-edge price of bucket 0. */
+  binMin: number
+  /** Price width of one bucket. `buckets.length * binSize = total price span`. */
+  binSize: number
+  /** Point of Control — center price of the highest-volume bucket. */
+  poc: number
+  /** Value Area High — upper edge price of the VAH bucket. */
+  vah: number
+  /** Value Area Low — lower edge price of the VAL bucket. */
+  val: number
+  /** Sum of every bucket. */
+  totalVolume: number
+  /** Volume inside the closed Value Area `[valIndex, vahIndex]`. */
+  vaVolume: number
 }
 
 /**
@@ -85,10 +85,10 @@ export interface VolumeProfileState {
  * `timestamp` so callers can stream from any source.
  */
 export interface VolumeProfileBar {
-    high: number
-    low: number
-    close: number
-    volume: number
+  high: number
+  low: number
+  close: number
+  volume: number
 }
 
 /**
@@ -97,35 +97,35 @@ export interface VolumeProfileBar {
  * `dispose`).
  */
 export interface VolumeProfileController {
-    /** Current config; re-emits when `setConfig` is called. */
-    readonly config: Signal<VolumeProfileConfig>
-    /** Current state; `null` until the first ingest. */
-    readonly state: Signal<VolumeProfileState | null>
+  /** Current config; re-emits when `setConfig` is called. */
+  readonly config: Signal<VolumeProfileConfig>
+  /** Current state; `null` until the first ingest. */
+  readonly state: Signal<VolumeProfileState | null>
 
-    /**
-     * Recompute the profile from a fresh bar slice. Idempotent: calling this
-     * twice with the same bars yields the same state (it is NOT cumulative —
-     * the prior buckets are discarded). Incremental ingestion will land with
-     * the GPU compute path; see `computeShader.wgsl.md`.
-     */
-    ingest(bars: ReadonlyArray<VolumeProfileBar>): void
+  /**
+   * Recompute the profile from a fresh bar slice. Idempotent: calling this
+   * twice with the same bars yields the same state (it is NOT cumulative —
+   * the prior buckets are discarded). Incremental ingestion will land with
+   * the GPU compute path; see `computeShader.wgsl.md`.
+   */
+  ingest(bars: ReadonlyArray<VolumeProfileBar>): void
 
-    /**
-     * Patch the config. If `binCount` changes the buckets are re-sized on the
-     * next `ingest` (state is cleared immediately because the old buckets are
-     * now meaningless under the new resolution).
-     */
-    setConfig(next: Partial<VolumeProfileConfig>): void
+  /**
+   * Patch the config. If `binCount` changes the buckets are re-sized on the
+   * next `ingest` (state is cleared immediately because the old buckets are
+   * now meaningless under the new resolution).
+   */
+  setConfig(next: Partial<VolumeProfileConfig>): void
 
-    /** Clear state to null (does not change config). */
-    reset(): void
+  /** Clear state to null (does not change config). */
+  reset(): void
 
-    /**
-     * Stop emitting. Subsequent calls to ingest/setConfig/reset are silent
-     * no-ops; previously-attached subscribers receive no further
-     * notifications. Idempotent.
-     */
-    dispose(): void
+  /**
+   * Stop emitting. Subsequent calls to ingest/setConfig/reset are silent
+   * no-ops; previously-attached subscribers receive no further
+   * notifications. Idempotent.
+   */
+  dispose(): void
 }
 
 /**
@@ -133,16 +133,16 @@ export interface VolumeProfileController {
  * indices; prices are derived by the controller using `binMin + binSize * i`.
  */
 export interface ValueAreaResult {
-    /** Upper bucket index (inclusive). */
-    vahIndex: number
-    /** Lower bucket index (inclusive). */
-    valIndex: number
-    /** Argmax bucket index used as the seed. */
-    pocIndex: number
-    /** Total of all buckets. */
-    totalVolume: number
-    /** Sum of `buckets[i]` for `i in [valIndex, vahIndex]`. */
-    vaVolume: number
-    /** `vaVolume / totalVolume`. 0 when `totalVolume` is 0. */
-    vaPercent: number
+  /** Upper bucket index (inclusive). */
+  vahIndex: number
+  /** Lower bucket index (inclusive). */
+  valIndex: number
+  /** Argmax bucket index used as the seed. */
+  pocIndex: number
+  /** Total of all buckets. */
+  totalVolume: number
+  /** Sum of `buckets[i]` for `i in [valIndex, vahIndex]`. */
+  vaVolume: number
+  /** `vaVolume / totalVolume`. 0 when `totalVolume` is 0. */
+  vaPercent: number
 }