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

package/src/components/mtfOverlay/createMtfController.ts

@@ -17,164 +17,165 @@ import type { Signal } from '../../reactivity'
 import { resampleBars } from './resampleBars'
 import { alignToBaseIndex } from './alignToBaseIndex'
 import type {
-    ActiveMtfSeries,
-    BaseBar,
-    MtfController,
-    MtfSeriesDefinition,
-    ResampledBar,
+  ActiveMtfSeries,
+  BaseBar,
+  MtfController,
+  MtfSeriesDefinition,
+  ResampledBar,
 } from './types'
 
 export interface CreateMtfControllerInit {
-    initialBars?: ReadonlyArray<BaseBar>
-    baseIntervalMs?: number
+  initialBars?: ReadonlyArray<BaseBar>
+  baseIntervalMs?: number
 }
 
 export function createMtfController(init: CreateMtfControllerInit = {}): MtfController {
-    let disposed = false
-    let baseBars: ReadonlyArray<BaseBar> = init.initialBars ?? []
-    let baseIntervalMs: number | null = init.baseIntervalMs ?? null
-
-    const definitions = new Map<string, MtfSeriesDefinition>()
-    const seriesSignal = createSignal<ReadonlyArray<ActiveMtfSeries>>([])
-
-    const computeOne = (def: MtfSeriesDefinition): ActiveMtfSeries => {
-        // No bars or no base interval set → empty aligned values (length 0,
-        // matching the empty base buffer).
-        if (baseBars.length === 0 || baseIntervalMs === null) {
-            return { definition: def, alignedValues: [] }
-        }
-        const resampled: ReadonlyArray<ResampledBar> = resampleBars(
-            baseBars,
-            baseIntervalMs,
-            def.targetIntervalMs,
-        )
-        const values = def.compute(resampled)
-        if (values.length !== resampled.length) {
-            throw new KLineChartError(
-                'MTF_CONFIG_INVALID',
-                `MtfController: compute fn for series "${def.id}" returned ` +
-                    `${values.length} values for ${resampled.length} resampled bars; ` +
-                    `length must match`,
-            )
-        }
-        const aligned = alignToBaseIndex(
-            baseBars,
-            resampled,
-            values,
-            def.targetIntervalMs,
-        )
-        return { definition: def, alignedValues: aligned }
+  let disposed = false
+  let baseBars: ReadonlyArray<BaseBar> = init.initialBars ?? []
+  let baseIntervalMs: number | null = init.baseIntervalMs ?? null
+
+  const definitions = new Map<string, MtfSeriesDefinition>()
+  const seriesSignal = createSignal<ReadonlyArray<ActiveMtfSeries>>([])
+
+  const computeOne = (def: MtfSeriesDefinition): ActiveMtfSeries => {
+    // No bars or no base interval set → empty aligned values (length 0,
+    // matching the empty base buffer).
+    if (baseBars.length === 0 || baseIntervalMs === null) {
+      return { definition: def, alignedValues: [] }
     }
-
-    const recomputeAll = (): void => {
-        const all: ActiveMtfSeries[] = []
-        for (const def of definitions.values()) {
-            all.push(computeOne(def))
-        }
-        seriesSignal.set(all)
+    const resampled: ReadonlyArray<ResampledBar> = resampleBars(
+      baseBars,
+      baseIntervalMs,
+      def.targetIntervalMs,
+    )
+    const values = def.compute(resampled)
+    if (values.length !== resampled.length) {
+      throw new KLineChartError(
+        'MTF_CONFIG_INVALID',
+        `MtfController: compute fn for series "${def.id}" returned ` +
+          `${values.length} values for ${resampled.length} resampled bars; ` +
+          `length must match`,
+      )
     }
-
-    const guard = (): boolean => !disposed
-
-    const validateInterval = (targetMs: number): void => {
-        if (!Number.isFinite(targetMs) || targetMs <= 0) {
-            throw new KLineChartError('MTF_CONFIG_INVALID', 'MtfController: targetIntervalMs must be > 0')
-        }
-        if (baseIntervalMs !== null && targetMs % baseIntervalMs !== 0) {
-            throw new KLineChartError(
-                'MTF_CONFIG_INVALID',
-                `MtfController: targetIntervalMs (${targetMs}) must be an ` +
-                    `integer multiple of baseIntervalMs (${baseIntervalMs})`,
-            )
-        }
+    const aligned = alignToBaseIndex(baseBars, resampled, values, def.targetIntervalMs)
+    return { definition: def, alignedValues: aligned }
+  }
+
+  const recomputeAll = (): void => {
+    const all: ActiveMtfSeries[] = []
+    for (const def of definitions.values()) {
+      all.push(computeOne(def))
     }
+    seriesSignal.set(all)
+  }
 
-    const inner: {
-        series: Signal<ReadonlyArray<ActiveMtfSeries>>
-        setBaseBars(bars: ReadonlyArray<BaseBar>, intervalMs: number): void
-        addSeries(def: MtfSeriesDefinition): string
-        removeSeries(id: string): boolean
-        updateSeries(id: string, patch: Partial<Omit<MtfSeriesDefinition, 'id'>>): boolean
-        appendBaseBar(bar: BaseBar): void
-        dispose(): void
-    } = {
-        series: seriesSignal,
-
-        setBaseBars(bars: ReadonlyArray<BaseBar>, intervalMs: number): void {
-            if (!guard()) return
-            if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
-                throw new KLineChartError('MTF_CONFIG_INVALID', 'MtfController.setBaseBars: baseIntervalMs must be > 0')
-            }
-            // If any series has a target that no longer cleanly divides, throw
-            // up front rather than letting resampleBars throw later.
-            for (const def of definitions.values()) {
-                if (def.targetIntervalMs % intervalMs !== 0) {
-                    throw new KLineChartError(
-                        'MTF_CONFIG_INVALID',
-                        `MtfController.setBaseBars: existing series "${def.id}" ` +
-                            `targetIntervalMs (${def.targetIntervalMs}) does not cleanly ` +
-                            `divide new baseIntervalMs (${intervalMs})`,
-                    )
-                }
-            }
-            baseBars = bars
-            baseIntervalMs = intervalMs
-            recomputeAll()
-        },
-
-        addSeries(def): string {
-            if (!guard()) return def.id
-            if (definitions.has(def.id)) {
-                throw new KLineChartError('MTF_CONFIG_INVALID', `MtfController.addSeries: id "${def.id}" already in use`)
-            }
-            validateInterval(def.targetIntervalMs)
-            definitions.set(def.id, def)
-            recomputeAll()
-            return def.id
-        },
-
-        removeSeries(id): boolean {
-            if (!guard()) return false
-            const had = definitions.delete(id)
-            if (had) recomputeAll()
-            return had
-        },
-
-        updateSeries(id, patch): boolean {
-            if (!guard()) return false
-            const existing = definitions.get(id)
-            if (existing === undefined) return false
-            const next: MtfSeriesDefinition = {
-                ...existing,
-                ...patch,
-                id: existing.id, // protect against accidental id mutation
-            }
-            if (patch.targetIntervalMs !== undefined) {
-                validateInterval(patch.targetIntervalMs)
-            }
-            definitions.set(id, next)
-            recomputeAll()
-            return true
-        },
-
-        appendBaseBar(bar): void {
-            if (!guard()) return
-            baseBars = [...baseBars, bar]
-            recomputeAll()
-        },
-
-        dispose(): void {
-            disposed = true
-            definitions.clear()
-        },
-    }
+  const guard = (): boolean => !disposed
 
-    // Canonical verbs (API audit BLOCKER-001): `setData` for full
-    // replacement, `append` for single-item extension. Old names
-    // preserved as aliases on the inner object for the deprecation window.
-    return {
-        ...inner,
-        setData: inner.setBaseBars,
-        append: inner.appendBaseBar,
+  const validateInterval = (targetMs: number): void => {
+    if (!Number.isFinite(targetMs) || targetMs <= 0) {
+      throw new KLineChartError('MTF_CONFIG_INVALID', 'MtfController: targetIntervalMs must be > 0')
+    }
+    if (baseIntervalMs !== null && targetMs % baseIntervalMs !== 0) {
+      throw new KLineChartError(
+        'MTF_CONFIG_INVALID',
+        `MtfController: targetIntervalMs (${targetMs}) must be an ` +
+          `integer multiple of baseIntervalMs (${baseIntervalMs})`,
+      )
     }
+  }
+
+  const inner: {
+    series: Signal<ReadonlyArray<ActiveMtfSeries>>
+    setBaseBars(bars: ReadonlyArray<BaseBar>, intervalMs: number): void
+    addSeries(def: MtfSeriesDefinition): string
+    removeSeries(id: string): boolean
+    updateSeries(id: string, patch: Partial<Omit<MtfSeriesDefinition, 'id'>>): boolean
+    appendBaseBar(bar: BaseBar): void
+    dispose(): void
+  } = {
+    series: seriesSignal,
+
+    setBaseBars(bars: ReadonlyArray<BaseBar>, intervalMs: number): void {
+      if (!guard()) return
+      if (!Number.isFinite(intervalMs) || intervalMs <= 0) {
+        throw new KLineChartError(
+          'MTF_CONFIG_INVALID',
+          'MtfController.setBaseBars: baseIntervalMs must be > 0',
+        )
+      }
+      // If any series has a target that no longer cleanly divides, throw
+      // up front rather than letting resampleBars throw later.
+      for (const def of definitions.values()) {
+        if (def.targetIntervalMs % intervalMs !== 0) {
+          throw new KLineChartError(
+            'MTF_CONFIG_INVALID',
+            `MtfController.setBaseBars: existing series "${def.id}" ` +
+              `targetIntervalMs (${def.targetIntervalMs}) does not cleanly ` +
+              `divide new baseIntervalMs (${intervalMs})`,
+          )
+        }
+      }
+      baseBars = bars
+      baseIntervalMs = intervalMs
+      recomputeAll()
+    },
+
+    addSeries(def): string {
+      if (!guard()) return def.id
+      if (definitions.has(def.id)) {
+        throw new KLineChartError(
+          'MTF_CONFIG_INVALID',
+          `MtfController.addSeries: id "${def.id}" already in use`,
+        )
+      }
+      validateInterval(def.targetIntervalMs)
+      definitions.set(def.id, def)
+      recomputeAll()
+      return def.id
+    },
+
+    removeSeries(id): boolean {
+      if (!guard()) return false
+      const had = definitions.delete(id)
+      if (had) recomputeAll()
+      return had
+    },
+
+    updateSeries(id, patch): boolean {
+      if (!guard()) return false
+      const existing = definitions.get(id)
+      if (existing === undefined) return false
+      const next: MtfSeriesDefinition = {
+        ...existing,
+        ...patch,
+        id: existing.id, // protect against accidental id mutation
+      }
+      if (patch.targetIntervalMs !== undefined) {
+        validateInterval(patch.targetIntervalMs)
+      }
+      definitions.set(id, next)
+      recomputeAll()
+      return true
+    },
+
+    appendBaseBar(bar): void {
+      if (!guard()) return
+      baseBars = [...baseBars, bar]
+      recomputeAll()
+    },
+
+    dispose(): void {
+      disposed = true
+      definitions.clear()
+    },
+  }
+
+  // Canonical verbs (API audit BLOCKER-001): `setData` for full
+  // replacement, `append` for single-item extension. Old names
+  // preserved as aliases on the inner object for the deprecation window.
+  return {
+    ...inner,
+    setData: inner.setBaseBars,
+    append: inner.appendBaseBar,
+  }
 }

package/src/components/mtfOverlay/index.ts

@@ -14,11 +14,11 @@
  */
 
 export type {
-    BaseBar,
-    ResampledBar,
-    MtfSeriesDefinition,
-    ActiveMtfSeries,
-    MtfController,
+  BaseBar,
+  ResampledBar,
+  MtfSeriesDefinition,
+  ActiveMtfSeries,
+  MtfController,
 } from './types'
 
 export { resampleBars } from './resampleBars'

package/src/components/mtfOverlay/resampleBars.ts

@@ -37,98 +37,104 @@ import type { BaseBar, ResampledBar } from './types'
  *   for stable user code. Closes API audit BLOCKER-002.
  */
 export function resampleBars(
-    bars: ReadonlyArray<BaseBar>,
-    baseIntervalMs: number,
-    targetIntervalMs: number,
+  bars: ReadonlyArray<BaseBar>,
+  baseIntervalMs: number,
+  targetIntervalMs: number,
 ): ReadonlyArray<ResampledBar> {
-    if (!Number.isFinite(baseIntervalMs) || baseIntervalMs <= 0) {
-        throw new KLineChartError('MTF_CONFIG_INVALID', 'resampleBars: baseIntervalMs must be a positive finite number')
-    }
-    if (!Number.isFinite(targetIntervalMs) || targetIntervalMs <= 0) {
-        throw new KLineChartError('MTF_CONFIG_INVALID', 'resampleBars: targetIntervalMs must be a positive finite number')
-    }
-    if (targetIntervalMs % baseIntervalMs !== 0) {
-        throw new KLineChartError(
-            'MTF_CONFIG_INVALID',
-            `resampleBars: targetIntervalMs (${targetIntervalMs}) must be an integer ` +
-                `multiple of baseIntervalMs (${baseIntervalMs}); got remainder ` +
-                `${targetIntervalMs % baseIntervalMs}`,
-        )
-    }
+  if (!Number.isFinite(baseIntervalMs) || baseIntervalMs <= 0) {
+    throw new KLineChartError(
+      'MTF_CONFIG_INVALID',
+      'resampleBars: baseIntervalMs must be a positive finite number',
+    )
+  }
+  if (!Number.isFinite(targetIntervalMs) || targetIntervalMs <= 0) {
+    throw new KLineChartError(
+      'MTF_CONFIG_INVALID',
+      'resampleBars: targetIntervalMs must be a positive finite number',
+    )
+  }
+  if (targetIntervalMs % baseIntervalMs !== 0) {
+    throw new KLineChartError(
+      'MTF_CONFIG_INVALID',
+      `resampleBars: targetIntervalMs (${targetIntervalMs}) must be an integer ` +
+        `multiple of baseIntervalMs (${baseIntervalMs}); got remainder ` +
+        `${targetIntervalMs % baseIntervalMs}`,
+    )
+  }
 
-    if (bars.length === 0) return []
+  if (bars.length === 0) return []
 
-    // Fast path: no aggregation required. Caller may still want shape parity
-    // (each base bar gets sourceStart === sourceEnd === its own index), so we
-    // wrap each base bar as a 1-source-bar `ResampledBar`.
-    if (targetIntervalMs === baseIntervalMs) {
-        const out: ResampledBar[] = new Array(bars.length)
-        for (let i = 0; i < bars.length; i++) {
-            const b = bars[i]
-            out[i] = {
-                timestamp: b.timestamp,
-                open: b.open,
-                high: b.high,
-                low: b.low,
-                close: b.close,
-                volume: b.volume,
-                sourceStart: i,
-                sourceEnd: i,
-            }
-        }
-        return out
+  // Fast path: no aggregation required. Caller may still want shape parity
+  // (each base bar gets sourceStart === sourceEnd === its own index), so we
+  // wrap each base bar as a 1-source-bar `ResampledBar`.
+  if (targetIntervalMs === baseIntervalMs) {
+    const out: ResampledBar[] = new Array(bars.length)
+    for (let i = 0; i < bars.length; i++) {
+      const b = bars[i]
+      out[i] = {
+        timestamp: b.timestamp,
+        open: b.open,
+        high: b.high,
+        low: b.low,
+        close: b.close,
+        volume: b.volume,
+        sourceStart: i,
+        sourceEnd: i,
+      }
     }
+    return out
+  }
 
-    const out: ResampledBar[] = []
-
-    let bucketStart = -1 // inclusive index in `bars`
-    let bucketTs = 0
-    let open = 0
-    let high = -Infinity
-    let low = Infinity
-    let close = 0
-    let volume = 0
+  const out: ResampledBar[] = []
 
-    const flush = (endIdx: number): void => {
-        if (bucketStart < 0) return
-        out.push({
-            timestamp: bucketTs,
-            open,
-            high,
-            low,
-            close,
-            volume,
-            sourceStart: bucketStart,
-            sourceEnd: endIdx,
-        })
-    }
+  let bucketStart = -1 // inclusive index in `bars`
+  let bucketTs = 0
+  let open = 0
+  let high = -Infinity
+  let low = Infinity
+  let close = 0
+  let volume = 0
 
-    for (let i = 0; i < bars.length; i++) {
-        const bar = bars[i]
-        const ts = Math.floor(bar.timestamp / targetIntervalMs) * targetIntervalMs
+  const flush = (endIdx: number): void => {
+    if (bucketStart < 0) return
+    out.push({
+      timestamp: bucketTs,
+      open,
+      high,
+      low,
+      close,
+      volume,
+      sourceStart: bucketStart,
+      sourceEnd: endIdx,
+    })
+  }
 
-        if (bucketStart < 0 || ts !== bucketTs) {
-            // Boundary crossed (or first iteration). Flush the previous bucket.
-            if (bucketStart >= 0) flush(i - 1)
-            bucketStart = i
-            bucketTs = ts
-            open = bar.open
-            high = bar.high
-            low = bar.low
-            close = bar.close
-            volume = bar.volume
-            continue
-        }
+  for (let i = 0; i < bars.length; i++) {
+    const bar = bars[i]
+    const ts = Math.floor(bar.timestamp / targetIntervalMs) * targetIntervalMs
 
-        // Same bucket: fold this bar in.
-        if (bar.high > high) high = bar.high
-        if (bar.low < low) low = bar.low
-        close = bar.close
-        volume += bar.volume
+    if (bucketStart < 0 || ts !== bucketTs) {
+      // Boundary crossed (or first iteration). Flush the previous bucket.
+      if (bucketStart >= 0) flush(i - 1)
+      bucketStart = i
+      bucketTs = ts
+      open = bar.open
+      high = bar.high
+      low = bar.low
+      close = bar.close
+      volume = bar.volume
+      continue
     }
 
-    // Final bucket — may be partial (fewer than targetIntervalMs/baseIntervalMs bars).
-    flush(bars.length - 1)
+    // Same bucket: fold this bar in.
+    if (bar.high > high) high = bar.high
+    if (bar.low < low) low = bar.low
+    close = bar.close
+    volume += bar.volume
+  }
 
-    return out
+  // Final bucket — may be partial (fewer than targetIntervalMs/baseIntervalMs bars).
+  flush(bars.length - 1)
+
+  return out
 }