@363045841yyt/klinechart-core 0.7.11 → 0.7.12

package/src/engine/renderers/Indicator/kama.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import { createSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import type { IndicatorScheduler, KAMASchedulerConfig } from '../../indicators/scheduler'
+import { calcKAMAData } from '../../indicators/calculators'
 
 const KAMA_COLOR = '#0ea5e9'
 
@@ -126,17 +127,17 @@ export function createKAMARendererPlugin(options: KAMARendererOptions = {}): Ren
     category: 'main',
     stateKey: createKAMAStateKey,
     defaultPaneId: 'main',
-    paneIdField: 'kamaPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'kama_main', toActiveConfig: (params, active) => ({ ...params, showKAMA: active }) },
     visibleState: { compose: createSparseVisibleStateComposer('kama', EMPTY_KAMA_STATE) },
     scale: { indicatorKey: 'kama', label: 'KAMA', decimals: 2 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateKAMAConfig(params as Partial<KAMASchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('kama', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createKAMAStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'kama', defaultConfig:{period:10,fastPeriod:2,slowPeriod:30,showKAMA:true}, computeKey:'calcKAMAData', compute:(data,c)=>calcKAMAData(data,c.period,c.fastPeriod,c.slowPeriod) },
 })
 class KAMADefinition {
     static rendererFactory = createKAMARendererPlugin

package/src/engine/renderers/Indicator/keltner.ts

@@ -5,6 +5,7 @@ import { createKeltnerStateKey, EMPTY_KELTNER_STATE } from '../../indicators/kel
 import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, KeltnerSchedulerConfig } from '../../indicators/scheduler'
+import { calcKeltnerData } from '../../indicators/calculators'
 import { createBandVisibleStateComposer } from '../../indicators/visibleStateComposers'
 
 const KELTNER_UPPER_COLOR = '#7c3aed'
@@ -128,17 +129,17 @@ function drawLine(ctx: CanvasRenderingContext2D, pts: Point[], color: string): v
     category: 'main',
     stateKey: createKeltnerStateKey,
     defaultPaneId: 'main',
-    paneIdField: 'keltnerPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'keltner_main', toActiveConfig: (params, active) => ({ ...params, showUpper: active, showMiddle: active, showLower: active }) },
     scale: { indicatorKey: 'keltner', label: 'Keltner', decimals: 2 },
     visibleState: { compose: createBandVisibleStateComposer('keltner', EMPTY_KELTNER_STATE, 'lower', 'upper') },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateKeltnerConfig(params as Partial<KeltnerSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('keltner', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createKeltnerStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'keltner', defaultConfig:{emaPeriod:20,atrPeriod:10,multiplier:2,showUpper:true,showMiddle:true,showLower:true}, computeKey:'calcKeltnerData', compute:(data,c)=>calcKeltnerData(data,c.emaPeriod,c.atrPeriod,c.multiplier) },
 })
 class KeltnerDefinition {
     static rendererFactory = createKeltnerRendererPlugin

package/src/engine/renderers/Indicator/kst.ts

@@ -9,6 +9,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, KSTSchedulerConfig } from '../../indicators/scheduler'
 import { createKstScaleRendererPlugin } from './scale/kst_scale'
+import { calcKSTData } from '../../indicators/calculators'
 
 type LinePoint = { x: number; y: number }
 
@@ -208,7 +209,7 @@ const { ctx, pane, range, scrollLeft, dpr, kLineCenters, lineWebGLSurface } = co
         },
 
         setConfig() {
-            // no-op: 配置通过 scheduler.updateKSTConfig() 更新
+            // no-op: 配置通过 scheduler.updateIndicatorConfig() 更新
         },
     }
 }
@@ -296,15 +297,15 @@ export function getKSTTitleInfo(
     category: 'oscillator',
     stateKey: createKSTStateKey,
     defaultPaneId: 'sub_KST',
-    paneIdField: 'kstPaneId',
     scaleRendererFactory: createKstScaleRendererPlugin,
     updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateKSTConfig(params as Partial<KSTSchedulerConfig>, paneId)
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('kst', params, paneId)
   },
     visibleState: { compose: createPaddedPointVisibleStateComposer('kst', EMPTY_KST_STATE, ['kst', 'signal'] as const) },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createKSTStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'kst', defaultConfig:{roc1:10,roc2:15,roc3:20,roc4:30,signalPeriod:9,showKST:true,showSignal:true}, computeKey:'calcKSTData', compute:(data,c)=>calcKSTData(data,c.roc1,c.roc2,c.roc3,c.roc4,c.signalPeriod) },
 })
 class KSTIndicatorDefinition {
     static rendererFactory = createKSTRendererPlugin

package/src/engine/renderers/Indicator/ma.ts

@@ -5,7 +5,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorPriceRangeComputer, IndicatorRenderStateComposer } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler } from '../../indicators/scheduler'
-import type { MAFlags } from '../../indicators/calculators'
+import { calcMAData, type MAFlags } from '../../indicators/calculators'
 import { alignToPhysicalPixelCenter } from '../../draw/pixelAlign'
 import { resolveThemeColors } from '../../../tokens'
 
@@ -112,7 +112,7 @@ function getMAStateKey(host: PluginHost | null): string | null {
         composeRenderState: composeMARenderState,
     },
     updateConfig: (scheduler, params) => {
-        (scheduler as IndicatorScheduler).updateMAConfig(params as MAFlags)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('ma', params)
     },
     semantic: {
         apply: (chart, indicator) => {
@@ -128,6 +128,7 @@ function getMAStateKey(host: PluginHost | null): string | null {
     applyResult: (host, state, _paneId) => {
         host.setSharedState(MA_STATE_KEY, state as any, 'ma_scheduler')
     },
+    runtime: { configKey:'ma', defaultConfig:{ma5:true,ma10:true,ma20:true,ma30:true,ma60:true}, computeKey:'calcMAData', compute:(data,c)=>{const p=[5,10,20,30,60];const r:Record<number,(number|undefined)[]>={};for(const o of p){if((c as any)['ma'+o])r[o]=calcMAData(data,o)}return r} },
 })
 class MADefinition {
     static rendererFactory = createMARendererPlugin

package/src/engine/renderers/Indicator/macd.ts

@@ -345,25 +345,25 @@ function drawMacdBarsWithCanvas2D(
   ctx.fillStyle = barUpColor
   for (let i = 0; i < barUpCount; i++) {
     const off = i * 4
-    ctx.fillRect(barUpBuf[off], barUpBuf[off + 1], barUpBuf[off + 2], barUpBuf[off + 3])
+    ctx.fillRect(barUpBuf[off]!, barUpBuf[off + 1]!, barUpBuf[off + 2]!, barUpBuf[off + 3]!)
   }
 
   ctx.fillStyle = barUpLightColor
   for (let i = 0; i < barUpLightCount; i++) {
     const off = i * 4
-    ctx.fillRect(barUpLightBuf[off], barUpLightBuf[off + 1], barUpLightBuf[off + 2], barUpLightBuf[off + 3])
+    ctx.fillRect(barUpLightBuf[off]!, barUpLightBuf[off + 1]!, barUpLightBuf[off + 2]!, barUpLightBuf[off + 3]!)
   }
 
   ctx.fillStyle = barDownColor
   for (let i = 0; i < barDownCount; i++) {
     const off = i * 4
-    ctx.fillRect(barDownBuf[off], barDownBuf[off + 1], barDownBuf[off + 2], barDownBuf[off + 3])
+    ctx.fillRect(barDownBuf[off]!, barDownBuf[off + 1]!, barDownBuf[off + 2]!, barDownBuf[off + 3]!)
   }
 
   ctx.fillStyle = barDownLightColor
   for (let i = 0; i < barDownLightCount; i++) {
     const off = i * 4
-    ctx.fillRect(barDownLightBuf[off], barDownLightBuf[off + 1], barDownLightBuf[off + 2], barDownLightBuf[off + 3])
+    ctx.fillRect(barDownLightBuf[off]!, barDownLightBuf[off + 1]!, barDownLightBuf[off + 2]!, barDownLightBuf[off + 3]!)
   }
 
   ctx.restore()
@@ -471,15 +471,15 @@ export function getMACDTitleInfo(
   category: 'oscillator',
   stateKey: createMACDStateKey,
   defaultPaneId: 'sub_MACD',
-  paneIdField: 'macdPaneId',
   scaleRendererFactory: createMacdScaleRendererPlugin,
   visibleState: { compose: createMACDVisibleStateComposer('macd', EMPTY_MACD_STATE) },
   updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateMACDConfig(params as Partial<MACDSchedulerConfig>, paneId)
-  },
-  applyResult: (host, state, paneId) => {
-    host.setSharedState(createMACDStateKey(paneId), state as any, 'indicator_scheduler')
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('macd', params, paneId)
   },
+    applyResult: (host, state, paneId) => {
+        host.setSharedState(createMACDStateKey(paneId), state as any, 'indicator_scheduler')
+    },
+    runtime: { configKey:'macd', defaultConfig:{fastPeriod:12,slowPeriod:26,signalPeriod:9,showDIF:true,showDEA:true,showBAR:true}, computeKey:'calcMACDData', compute:(data,c)=>calcMACDData(data,c.fastPeriod,c.slowPeriod,c.signalPeriod) },
 })
 class MACDIndicatorDefinition {
   static rendererFactory = createMACDRendererPlugin

package/src/engine/renderers/Indicator/mfi.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { createFixedRangeSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, MFISchedulerConfig } from '../../indicators/scheduler'
+import { calcMFIData } from '../../indicators/calculators'
 
 const MFI_COLOR = '#fb923c'
 
@@ -133,15 +134,20 @@ export function createMFIRendererPlugin(options: { paneId?: string } = {}): Rend
     category: 'volume',
     stateKey: createMFIStateKey,
     defaultPaneId: 'sub_MFI',
-    paneIdField: 'mfiPaneId',
     visibleState: { compose: createFixedRangeSparseVisibleStateComposer('mfi', EMPTY_MFI_STATE) },
     scale: { indicatorKey: 'mfi', label: 'MFI', decimals: 2 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateMFIConfig(params as Partial<MFISchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('mfi', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createMFIStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: {
+        configKey: 'mfi',
+        defaultConfig: { period: 14, showMFI: true },
+        computeKey: 'calcMFIData',
+        compute: (data, c) => calcMFIData(data, c.period),
+    },
 })
 class MFIIndicatorDefinition {
     static rendererFactory = createMFIRendererPlugin

package/src/engine/renderers/Indicator/mom.ts

@@ -10,6 +10,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, MOMSchedulerConfig } from '../../indicators/scheduler'
 import { createMomScaleRendererPlugin } from './scale/mom_scale'
+import { calcMOMData } from '../../indicators/calculators'
 
 type LinePoint = { x: number; y: number }
 
@@ -239,7 +240,7 @@ const { ctx, pane, range, scrollLeft, dpr, kLineCenters, lineWebGLSurface } = co
         },
 
         setConfig() {
-            // no-op: 配置通过 scheduler.updateMOMConfig() 更新
+            // no-op: 配置通过 scheduler.updateIndicatorConfig() 更新
         },
     }
 }
@@ -305,15 +306,20 @@ export function getMOMTitleInfo(
     category: 'oscillator',
     stateKey: createMOMStateKey,
     defaultPaneId: 'sub_MOM',
-    paneIdField: 'momPaneId',
     scaleRendererFactory: createMomScaleRendererPlugin,
     updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateMOMConfig(params as Partial<MOMSchedulerConfig>, paneId)
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('mom', params, paneId)
   },
     visibleState: { compose: createPaddedSparseVisibleStateComposer('mom', EMPTY_MOM_STATE) },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createMOMStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: {
+        configKey: 'mom',
+        defaultConfig: { period: 10, showMOM: true },
+        computeKey: 'calcMOMData',
+        compute: (data, c) => calcMOMData(data, c.period),
+    },
 })
 class MOMIndicatorDefinition {
     static rendererFactory = createMOMRendererPlugin

package/src/engine/renderers/Indicator/obv.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import { createSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import type { IndicatorScheduler, OBVSchedulerConfig } from '../../indicators/scheduler'
+import { calcOBVData } from '../../indicators/calculators'
 
 const OBV_COLOR = '#16a34a'
 
@@ -114,15 +115,20 @@ export function createOBVRendererPlugin(options: { paneId?: string } = {}): Rend
     category: 'volume',
     stateKey: createOBVStateKey,
     defaultPaneId: 'sub_OBV',
-    paneIdField: 'obvPaneId',
     visibleState: { compose: createSparseVisibleStateComposer('obv', EMPTY_OBV_STATE) },
     scale: { indicatorKey: 'obv', label: 'OBV', decimals: 0 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateOBVConfig(params as Partial<OBVSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('obv', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createOBVStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: {
+        configKey: 'obv',
+        defaultConfig: { showOBV: true },
+        computeKey: 'calcOBVData',
+        compute: (data, c) => calcOBVData(data),
+    },
 })
 class OBVIndicatorDefinition {
     static rendererFactory = createOBVRendererPlugin

package/src/engine/renderers/Indicator/parkinson.ts

@@ -7,6 +7,7 @@ import { createNonNegativeSparseVisibleStateComposer } from '../../indicators/vi
 import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, ParkinsonSchedulerConfig } from '../../indicators/scheduler'
+import { calcParkinsonData } from '../../indicators/calculators'
 
 const PARKINSON_COLOR = '#0891b2'
 
@@ -116,15 +117,15 @@ export function createParkinsonRendererPlugin(options: { paneId?: string } = {})
     category: 'oscillator',
     stateKey: createParkinsonStateKey,
     defaultPaneId: 'sub_Parkinson',
-    paneIdField: 'parkinsonPaneId',
     scale: { indicatorKey: 'parkinson', label: 'Parkinson', decimals: 2 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateParkinsonConfig(params as Partial<ParkinsonSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('parkinson', params, paneId)
     },
     visibleState: { compose: createNonNegativeSparseVisibleStateComposer('parkinson', EMPTY_PARKINSON_STATE) },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createParkinsonStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'parkinson', defaultConfig:{period:20,annualizationFactor:252,showParkinson:true}, computeKey:'calcParkinsonData', compute:(data,c)=>calcParkinsonData(data,c.period,c.annualizationFactor) },
 })
 class ParkinsonIndicatorDefinition {
     static rendererFactory = createParkinsonRendererPlugin

package/src/engine/renderers/Indicator/pivot.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, PivotSchedulerConfig } from '../../indicators/scheduler'
 import { createExactRangePointVisibleStateComposer } from '../../indicators/visibleStateComposers'
+import { calcPivotData } from '../../indicators/calculators'
 
 const PP_COLOR = '#94a3b8'
 const R_COLOR = '#dc2626'
@@ -121,17 +122,17 @@ function drawStep(ctx: CanvasRenderingContext2D, pts: Point[], color: string): v
     category: 'main',
     stateKey: createPivotStateKey,
     defaultPaneId: 'main',
-    paneIdField: 'pivotPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'pivot_main', toActiveConfig: (params, active) => ({ ...params, showPP: active, showR1: active, showR2: active, showR3: active, showS1: active, showS2: active, showS3: active }) },
     scale: { indicatorKey: 'pivot', label: 'Pivot', decimals: 2 },
     visibleState: { compose: createExactRangePointVisibleStateComposer('pivot', EMPTY_PIVOT_STATE, ['pp', 'r1', 'r2', 'r3', 's1', 's2', 's3']) },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updatePivotConfig(params as Partial<PivotSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('pivot', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createPivotStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'pivot', defaultConfig:{showPP:true,showR1:true,showR2:true,showR3:true,showS1:true,showS2:true,showS3:true}, computeKey:'calcPivotData', compute:(data,c)=>calcPivotData(data) },
 })
 class PivotDefinition {
     static rendererFactory = createPivotRendererPlugin

package/src/engine/renderers/Indicator/pvt.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import { createSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import type { IndicatorScheduler, PVTSchedulerConfig } from '../../indicators/scheduler'
+import { calcPVTData } from '../../indicators/calculators'
 
 const PVT_COLOR = '#a855f7'
 
@@ -114,15 +115,20 @@ export function createPVTRendererPlugin(options: { paneId?: string } = {}): Rend
     category: 'volume',
     stateKey: createPVTStateKey,
     defaultPaneId: 'sub_PVT',
-    paneIdField: 'pvtPaneId',
     visibleState: { compose: createSparseVisibleStateComposer('pvt', EMPTY_PVT_STATE) },
     scale: { indicatorKey: 'pvt', label: 'PVT', decimals: 0 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updatePVTConfig(params as Partial<PVTSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('pvt', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createPVTStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: {
+        configKey: 'pvt',
+        defaultConfig: { showPVT: true },
+        computeKey: 'calcPVTData',
+        compute: (data, c) => calcPVTData(data),
+    },
 })
 class PVTIndicatorDefinition {
     static rendererFactory = createPVTRendererPlugin

package/src/engine/renderers/Indicator/roc.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import { createSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import type { IndicatorScheduler, ROCSchedulerConfig } from '../../indicators/scheduler'
+import { calcROCData } from '../../indicators/calculators'
 
 const ROC_COLOR = '#0ea5e9'
 
@@ -134,15 +135,20 @@ export function createROCRendererPlugin(options: ROCRendererOptions = {}): Rende
     category: 'oscillator',
     stateKey: createROCStateKey,
     defaultPaneId: 'sub_ROC',
-    paneIdField: 'rocPaneId',
     visibleState: { compose: createSparseVisibleStateComposer('roc', EMPTY_ROC_STATE) },
     scale: { indicatorKey: 'roc', label: 'ROC', decimals: 2 },
     updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateROCConfig(params as Partial<ROCSchedulerConfig>, paneId)
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('roc', params, paneId)
   },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createROCStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: {
+        configKey: 'roc',
+        defaultConfig: { period: 12, showROC: true },
+        computeKey: 'calcROCData',
+        compute: (data, c) => calcROCData(data, c.period),
+    },
 })
 class ROCIndicatorDefinition {
     static rendererFactory = createROCRendererPlugin

package/src/engine/renderers/Indicator/rsi.ts

@@ -9,6 +9,7 @@ import { createFixedRangeRecordVisibleStateComposer } from '../../indicators/vis
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, RSISchedulerConfig } from '../../indicators/scheduler'
 import { createRsiScaleRendererPlugin } from './scale/rsi_scale'
+import { calcRSIData } from '../../indicators/calculators'
 
 type LinePoint = { x: number; y: number }
 
@@ -287,7 +288,7 @@ const { ctx, pane, range, scrollLeft, dpr, kLineCenters, lineWebGLSurface } = co
         },
 
         setConfig(_newConfig: Record<string, unknown>) {
-            // 无状态渲染器：配置变更请使用 chart.getIndicatorScheduler().updateRSIConfig()
+            // 无状态渲染器：配置变更请使用 chart.getIndicatorScheduler().updateIndicatorConfig()
         },
     }
 }
@@ -389,15 +390,15 @@ export function getRSITitleInfo(
     category: 'oscillator',
     stateKey: createRSIStateKey,
     defaultPaneId: 'sub_RSI',
-    paneIdField: 'rsiPaneId',
     visibleState: { compose: createFixedRangeRecordVisibleStateComposer('rsi', EMPTY_RSI_STATE) },
     scaleRendererFactory: createRsiScaleRendererPlugin,
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateRSIConfig(params as Partial<RSISchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('rsi', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createRSIStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'rsi', defaultConfig:{period1:6,period2:12,period3:24,showRSI1:true,showRSI2:true,showRSI3:true}, computeKey:'calcRSIData', compute:(data,c)=>{const p=[c.period1,c.period2,c.period3];const s=[c.showRSI1,c.showRSI2,c.showRSI3];const r:Record<number,(number|undefined)[]>={};for(let i=0;i<3;i++){if(s[i])r[p[i]]=calcRSIData(data,p[i])}return r} },
 })
 class RSIIndicatorDefinition {
     static rendererFactory = createRSIRendererPlugin

package/src/engine/renderers/Indicator/sar.ts

@@ -5,6 +5,7 @@ import { createSARStateKey, EMPTY_SAR_STATE } from '../../indicators/sarState'
 import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, SARSchedulerConfig } from '../../indicators/scheduler'
+import { calcSARData } from '../../indicators/calculators'
 import { createValuePointVisibleStateComposer } from '../../indicators/visibleStateComposers'
 
 const SAR_UP_COLOR = '#22c55e'
@@ -103,17 +104,17 @@ export function createSARRendererPlugin(options: SARRendererOptions = {}): Rende
     category: 'main',
     stateKey: createSARStateKey,
     defaultPaneId: 'main',
-    paneIdField: 'sarPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'sar_main', toActiveConfig: (params, active) => ({ ...params, showSAR: active }) },
     scale: { indicatorKey: 'sar', label: 'SAR', decimals: 4 },
     visibleState: { compose: createValuePointVisibleStateComposer('sar', EMPTY_SAR_STATE, ['value']) },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateSARConfig(params as Partial<SARSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('sar', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createSARStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'sar', defaultConfig:{step:0.02,maxStep:0.2,showSAR:true}, computeKey:'calcSARData', compute:(data,c)=>calcSARData(data,c.step,c.maxStep) },
 })
 class SARDefinition {
     static rendererFactory = createSARRendererPlugin

package/src/engine/renderers/Indicator/stoch.ts

@@ -9,6 +9,7 @@ import { createFixedRangePointVisibleStateComposer } from '../../indicators/visi
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, STOCHSchedulerConfig } from '../../indicators/scheduler'
 import { createStochScaleRendererPlugin } from './scale/stoch_scale'
+import { calcSTOCHData } from '../../indicators/calculators'
 
 type LinePoint = { x: number; y: number }
 
@@ -267,7 +268,7 @@ const { ctx, pane, range, scrollLeft, dpr, kLineCenters, lineWebGLSurface } = co
         },
 
         setConfig() {
-            // no-op: 配置通过 scheduler.updateSTOCHConfig() 更新
+            // no-op: 配置通过 scheduler.updateIndicatorConfig() 更新
         },
     }
 }
@@ -352,15 +353,15 @@ export function getSTOCHTitleInfo(
     category: 'oscillator',
     stateKey: createSTOCHStateKey,
     defaultPaneId: 'sub_STOCH',
-    paneIdField: 'stochPaneId',
     visibleState: { compose: createFixedRangePointVisibleStateComposer('stoch', EMPTY_STOCH_STATE, ['k', 'd'] as const) },
     scaleRendererFactory: createStochScaleRendererPlugin,
     updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateSTOCHConfig(params as Partial<STOCHSchedulerConfig>, paneId)
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('stoch', params, paneId)
   },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createSTOCHStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'stoch', defaultConfig:{n:9,m:3,showK:true,showD:true}, computeKey:'calcSTOCHData', compute:(data,c)=>calcSTOCHData(data,c.n,c.m) },
 })
 class STOCHIndicatorDefinition {
     static rendererFactory = createSTOCHRendererPlugin

package/src/engine/renderers/Indicator/structure.ts

@@ -7,6 +7,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { createFixedUnitVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, StructureSchedulerConfig } from '../../indicators/scheduler'
+import { calcStructureData } from '../../indicators/calculators'
 
 const LABEL_FONT = '11px sans-serif'
 
@@ -116,17 +117,17 @@ export function createStructureRendererPlugin(options: { paneId?: string } = {})
     category: 'sub',
     stateKey: createStructureStateKey,
     defaultPaneId: 'sub_Structure',
-    paneIdField: 'structurePaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'structure_main', toActiveConfig: (params, active) => ({ ...params, showSwingLabels: active, showBOS: active, showCHOCH: active }) },
     scale: { indicatorKey: 'structure', label: 'Structure', decimals: 2 },
     visibleState: { compose: createFixedUnitVisibleStateComposer('structure', EMPTY_STRUCTURE_STATE) },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateStructureConfig(params as Partial<StructureSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('structure', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createStructureStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'structure', defaultConfig:{leftWindow:5,rightWindow:2,breakoutSource:'close',showSwingLabels:true,showBOS:true,showCHOCH:true,showProvisional:true}, computeKey:'calcStructureData', compute:(data,c)=>calcStructureData(data,c.leftWindow,c.rightWindow,c.breakoutSource) },
 })
 class StructureIndicatorDefinition {
     static rendererFactory = createStructureRendererPlugin

package/src/engine/renderers/Indicator/supertrend.ts

@@ -5,6 +5,7 @@ import { createSuperTrendStateKey, EMPTY_SUPERTREND_STATE } from '../../indicato
 import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, SuperTrendSchedulerConfig } from '../../indicators/scheduler'
+import { calcSuperTrendData } from '../../indicators/calculators'
 import { createValuePointVisibleStateComposer } from '../../indicators/visibleStateComposers'
 
 const ST_UP_COLOR = '#22c55e'
@@ -105,17 +106,17 @@ export function createSuperTrendRendererPlugin(options: SuperTrendRendererOption
     category: 'oscillator',
     stateKey: createSuperTrendStateKey,
     defaultPaneId: 'sub_SuperTrend',
-    paneIdField: 'supertrendPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'supertrend_main', toActiveConfig: (params, active) => ({ ...params, showSuperTrend: active }) },
     scale: { indicatorKey: 'supertrend', label: 'SuperTrend', decimals: 2 },
     visibleState: { compose: createValuePointVisibleStateComposer('supertrend', EMPTY_SUPERTREND_STATE, ['value']) },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateSuperTrendConfig(params as Partial<SuperTrendSchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('supertrend', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createSuperTrendStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'supertrend', defaultConfig:{atrPeriod:10,multiplier:3,showSuperTrend:true}, computeKey:'calcSuperTrendData', compute:(data,c)=>calcSuperTrendData(data,c.atrPeriod,c.multiplier) },
 })
 class SuperTrendIndicatorDefinition {
     static rendererFactory = createSuperTrendRendererPlugin

package/src/engine/renderers/Indicator/tema.ts

@@ -6,6 +6,7 @@ import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import { createSparseVisibleStateComposer } from '../../indicators/visibleStateComposers'
 import type { IndicatorScheduler, TEMASchedulerConfig } from '../../indicators/scheduler'
+import { calcTEMAData } from '../../indicators/calculators'
 
 const TEMA_COLOR = '#d946ef'
 
@@ -126,17 +127,17 @@ export function createTEMARendererPlugin(options: TEMARendererOptions = {}): Ren
     category: 'main',
     stateKey: createTEMAStateKey,
     defaultPaneId: 'main',
-    paneIdField: 'temaPaneId',
     allowMainPane: true,
     mainPane: { rendererName: 'tema_main', toActiveConfig: (params, active) => ({ ...params, showTEMA: active }) },
     visibleState: { compose: createSparseVisibleStateComposer('tema', EMPTY_TEMA_STATE) },
     scale: { indicatorKey: 'tema', label: 'TEMA', decimals: 2 },
     updateConfig: (scheduler, params, paneId) => {
-        (scheduler as IndicatorScheduler).updateTEMAConfig(params as Partial<TEMASchedulerConfig>, paneId)
+        (scheduler as IndicatorScheduler).updateIndicatorConfig('tema', params, paneId)
     },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createTEMAStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'tema', defaultConfig:{period:14,showTEMA:true}, computeKey:'calcTEMAData', compute:(data,c)=>calcTEMAData(data,c.period) },
 })
 class TEMADefinition {
     static rendererFactory = createTEMARendererPlugin

package/src/engine/renderers/Indicator/trix.ts

@@ -7,6 +7,7 @@ import { createDualSparseVisibleStateComposer } from '../../indicators/visibleSt
 import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
 import { resolveStateKey } from '../../indicators/indicatorMetadata'
 import type { IndicatorScheduler, TRIXSchedulerConfig } from '../../indicators/scheduler'
+import { calcTRIXData } from '../../indicators/calculators'
 
 const TRIX_COLOR = '#e11d48'
 const SIGNAL_COLOR = '#f59e0b'
@@ -150,15 +151,15 @@ function drawLine(ctx: CanvasRenderingContext2D, pts: Point[], color: string): v
     category: 'oscillator',
     stateKey: createTRIXStateKey,
     defaultPaneId: 'sub_TRIX',
-    paneIdField: 'trixPaneId',
     scale: { indicatorKey: 'trix', label: 'TRIX', decimals: 6 },
     updateConfig: (scheduler, params, paneId) => {
-    (scheduler as IndicatorScheduler).updateTRIXConfig(params as Partial<TRIXSchedulerConfig>, paneId)
+    (scheduler as IndicatorScheduler).updateIndicatorConfig('trix', params, paneId)
   },
     visibleState: { compose: createDualSparseVisibleStateComposer('trix', EMPTY_TRIX_STATE) },
     applyResult: (host, state, paneId) => {
         host.setSharedState(createTRIXStateKey(paneId), state as any, 'indicator_scheduler')
     },
+    runtime: { configKey:'trix', defaultConfig:{period:15,signalPeriod:9,showTRIX:true,showSignal:true}, computeKey:'calcTRIXData', compute:(data,c)=>calcTRIXData(data,c.period,c.signalPeriod) },
 })
 class TRIXIndicatorDefinition {
     static rendererFactory = createTRIXRendererPlugin