@363045841yyt/klinechart-core 0.7.9 → 0.7.10

package/src/engine/subPaneManager.ts

@@ -3,54 +3,7 @@ import type { SubIndicatorType } from './renderers/Indicator'
 import { createSignal, type Signal } from '../reactivity/signal'
 import { createSubIndicatorRenderer } from './renderers/Indicator'
 import { createPaneTitleRendererPlugin } from './renderers/paneTitle'
-import { createVolumeScaleRendererPlugin } from './renderers/Indicator/scale/volume_scale'
-import { createMacdScaleRendererPlugin } from './renderers/Indicator/scale/macd_scale'
-import { createRsiScaleRendererPlugin } from './renderers/Indicator/scale/rsi_scale'
-import { createCciScaleRendererPlugin } from './renderers/Indicator/scale/cci_scale'
-import { createStochScaleRendererPlugin } from './renderers/Indicator/scale/stoch_scale'
-import { createMomScaleRendererPlugin } from './renderers/Indicator/scale/mom_scale'
-import { createWmsrScaleRendererPlugin } from './renderers/Indicator/scale/wmsr_scale'
-import { createKstScaleRendererPlugin } from './renderers/Indicator/scale/kst_scale'
-import { createFastkScaleRendererPlugin } from './renderers/Indicator/scale/fastk_scale'
-import { createAtrScaleRendererPlugin } from './renderers/Indicator/scale/atr_scale'
 import { createIndicatorScaleRendererPlugin } from './renderers/Indicator/scale/indicator_scale'
-import type {
-    RSISchedulerConfig,
-    CCISchedulerConfig,
-    STOCHSchedulerConfig,
-    MOMSchedulerConfig,
-    WMSRSchedulerConfig,
-    KSTSchedulerConfig,
-    FASTKSchedulerConfig,
-    ATRSchedulerConfig,
-    WMASchedulerConfig,
-    DEMASchedulerConfig,
-    TEMASchedulerConfig,
-    HMASchedulerConfig,
-    KAMASchedulerConfig,
-    SARSchedulerConfig,
-    SuperTrendSchedulerConfig,
-    KeltnerSchedulerConfig,
-    DonchianSchedulerConfig,
-    IchimokuSchedulerConfig,
-    ROCSchedulerConfig,
-    TRIXSchedulerConfig,
-    HVSchedulerConfig,
-    ParkinsonSchedulerConfig,
-    ChaikinVolSchedulerConfig,
-    VMASchedulerConfig,
-    OBVSchedulerConfig,
-    PVTSchedulerConfig,
-    VWAPSchedulerConfig,
-    CMFSchedulerConfig,
-    MFISchedulerConfig,
-    PivotSchedulerConfig,
-    FibSchedulerConfig,
-    StructureSchedulerConfig,
-    ZonesSchedulerConfig,
-    VolumeProfileSchedulerConfig,
-} from './indicators/scheduler'
-import type { MACDSchedulerConfig } from './indicators/macdState'
 
 export interface SubPaneEntry {
     paneId: string
@@ -78,9 +31,11 @@ export class SubPaneManager {
             return true
         }
 
-        const rendererName = `${indicatorId.toLowerCase()}_${paneId}`
         const scaleRendererName = `${indicatorId.toLowerCase()}_scale_${paneId}`
         const paneTitleRendererName = `paneTitle_${paneId}`
+        const renderer = this.createIndicatorRenderer(chart, paneId, indicatorId, params)
+        if (!renderer) return false
+        const rendererName = renderer.name
 
         const paneExists = chart.hasPane(paneId)
         if (!paneExists) {
@@ -89,7 +44,6 @@ export class SubPaneManager {
 
         const existingRenderer = chart.getRenderer(rendererName)
         if (!existingRenderer) {
-            const renderer = createSubIndicatorRenderer({ indicatorId, paneId })
             chart.useRenderer(renderer, params as Record<string, number | boolean | string>)
         }
 
@@ -136,11 +90,12 @@ export class SubPaneManager {
         chart.removeRenderer(entry.scaleRendererName)
         chart.removeRenderer(entry.paneTitleRendererName)
 
-        const newRendererName = `${newIndicatorId.toLowerCase()}_${paneId}`
         const newScaleRendererName = `${newIndicatorId.toLowerCase()}_scale_${paneId}`
         const newPaneTitleRendererName = `paneTitle_${paneId}`
+        const renderer = this.createIndicatorRenderer(chart, paneId, newIndicatorId, newParams)
+        if (!renderer) return
+        const newRendererName = renderer.name
 
-        const renderer = createSubIndicatorRenderer({ indicatorId: newIndicatorId, paneId })
         chart.useRenderer(renderer, newParams as Record<string, number | boolean | string>)
 
         this.mountScaleRenderer(chart, paneId, newIndicatorId, newScaleRendererName)
@@ -177,6 +132,19 @@ export class SubPaneManager {
         return this.entries.get(paneId)
     }
 
+    private createIndicatorRenderer(
+        chart: Chart,
+        paneId: string,
+        indicatorId: SubIndicatorType,
+        params: Record<string, unknown>,
+    ): import('../plugin').RendererPlugin {
+        const definition = chart.getIndicatorScheduler().getIndicatorMetadata(indicatorId)
+        if (!definition) {
+            throw new Error(`[SubPaneManager] Unknown indicator: ${indicatorId}`)
+        }
+        return createSubIndicatorRenderer({ indicatorId, paneId, definition, params })
+    }
+
     getAll(): SubPaneEntry[] {
         return Array.from(this.entries.values())
     }
@@ -203,116 +171,8 @@ export class SubPaneManager {
         params: Record<string, unknown>,
     ): void {
         const scheduler = chart.getIndicatorScheduler()
-        switch (indicatorId) {
-            case 'MACD':
-                scheduler.updateMACDConfig(params as Partial<MACDSchedulerConfig>, paneId)
-                break
-            case 'RSI':
-                scheduler.updateRSIConfig(params as Partial<RSISchedulerConfig>, paneId)
-                break
-            case 'CCI':
-                scheduler.updateCCIConfig(params as Partial<CCISchedulerConfig>, paneId)
-                break
-            case 'STOCH':
-                scheduler.updateSTOCHConfig(params as Partial<STOCHSchedulerConfig>, paneId)
-                break
-            case 'MOM':
-                scheduler.updateMOMConfig(params as Partial<MOMSchedulerConfig>, paneId)
-                break
-            case 'WMSR':
-                scheduler.updateWMSRConfig(params as Partial<WMSRSchedulerConfig>, paneId)
-                break
-            case 'KST':
-                scheduler.updateKSTConfig(params as Partial<KSTSchedulerConfig>, paneId)
-                break
-            case 'FASTK':
-                scheduler.updateFASTKConfig(params as Partial<FASTKSchedulerConfig>, paneId)
-                break
-            case 'ATR':
-                console.log(`[ATR-SubPane] syncSchedulerConfig: paneId=${paneId} params=${JSON.stringify(params)}`)
-                scheduler.updateATRConfig(params as Partial<ATRSchedulerConfig>, paneId)
-                break
-            case 'WMA':
-                scheduler.updateWMAConfig(params as Partial<WMASchedulerConfig>, paneId)
-                break
-            case 'DEMA':
-                scheduler.updateDEMAConfig(params as Partial<DEMASchedulerConfig>, paneId)
-                break
-            case 'TEMA':
-                scheduler.updateTEMAConfig(params as Partial<TEMASchedulerConfig>, paneId)
-                break
-            case 'HMA':
-                scheduler.updateHMAConfig(params as Partial<HMASchedulerConfig>, paneId)
-                break
-            case 'KAMA':
-                scheduler.updateKAMAConfig(params as Partial<KAMASchedulerConfig>, paneId)
-                break
-            case 'SAR':
-                scheduler.updateSARConfig(params as Partial<SARSchedulerConfig>, paneId)
-                break
-            case 'SUPERTREND':
-                scheduler.updateSuperTrendConfig(params as Partial<SuperTrendSchedulerConfig>, paneId)
-                break
-            case 'KELTNER':
-                scheduler.updateKeltnerConfig(params as Partial<KeltnerSchedulerConfig>, paneId)
-                break
-            case 'DONCHIAN':
-                scheduler.updateDonchianConfig(params as Partial<DonchianSchedulerConfig>, paneId)
-                break
-            case 'ICHIMOKU':
-                scheduler.updateIchimokuConfig(params as Partial<IchimokuSchedulerConfig>, paneId)
-                break
-            case 'ROC':
-                scheduler.updateROCConfig(params as Partial<ROCSchedulerConfig>, paneId)
-                break
-            case 'TRIX':
-                scheduler.updateTRIXConfig(params as Partial<TRIXSchedulerConfig>, paneId)
-                break
-            case 'HV':
-                scheduler.updateHVConfig(params as Partial<HVSchedulerConfig>, paneId)
-                break
-            case 'PARKINSON':
-                scheduler.updateParkinsonConfig(params as Partial<ParkinsonSchedulerConfig>, paneId)
-                break
-            case 'CHAIKIN_VOL':
-                scheduler.updateChaikinVolConfig(params as Partial<ChaikinVolSchedulerConfig>, paneId)
-                break
-            case 'VMA':
-                scheduler.updateVMAConfig(params as Partial<VMASchedulerConfig>, paneId)
-                break
-            case 'OBV':
-                scheduler.updateOBVConfig(params as Partial<OBVSchedulerConfig>, paneId)
-                break
-            case 'PVT':
-                scheduler.updatePVTConfig(params as Partial<PVTSchedulerConfig>, paneId)
-                break
-            case 'VWAP':
-                scheduler.updateVWAPConfig(params as Partial<VWAPSchedulerConfig>, paneId)
-                break
-            case 'CMF':
-                scheduler.updateCMFConfig(params as Partial<CMFSchedulerConfig>, paneId)
-                break
-            case 'MFI':
-                scheduler.updateMFIConfig(params as Partial<MFISchedulerConfig>, paneId)
-                break
-            case 'PIVOT':
-                scheduler.updatePivotConfig(params as Partial<PivotSchedulerConfig>, paneId)
-                break
-            case 'FIB':
-                scheduler.updateFibConfig(params as Partial<FibSchedulerConfig>, paneId)
-                break
-            case 'STRUCTURE':
-                scheduler.updateStructureConfig(params as Partial<StructureSchedulerConfig>, paneId)
-                break
-            case 'ZONES':
-                scheduler.updateZonesConfig(params as Partial<ZonesSchedulerConfig>, paneId)
-                break
-            case 'VOLUME_PROFILE':
-                scheduler.updateVolumeProfileConfig(params as Partial<VolumeProfileSchedulerConfig>, paneId)
-                break
-            case 'VOLUME':
-                break
-        }
+        const definition = scheduler.getIndicatorMetadata(indicatorId)
+        definition?.updateConfig?.(scheduler, params, paneId)
     }
 
     private mountScaleRenderer(chart: Chart, paneId: string, indicatorId: SubIndicatorType, scaleRendererName: string): void {
@@ -333,121 +193,21 @@ export class SubPaneManager {
 
         const opts = { axisWidth, paneId, yPaddingPx, getCrosshair }
 
-        let renderer: import('../plugin').RendererPluginWithHost
-        switch (indicatorId) {
-            case 'VOLUME':
-                renderer = createVolumeScaleRendererPlugin(opts)
-                break
-            case 'MACD':
-                renderer = createMacdScaleRendererPlugin(opts)
-                break
-            case 'RSI':
-                renderer = createRsiScaleRendererPlugin(opts)
-                break
-            case 'CCI':
-                renderer = createCciScaleRendererPlugin(opts)
-                break
-            case 'STOCH':
-                renderer = createStochScaleRendererPlugin(opts)
-                break
-            case 'MOM':
-                renderer = createMomScaleRendererPlugin(opts)
-                break
-            case 'WMSR':
-                renderer = createWmsrScaleRendererPlugin(opts)
-                break
-            case 'KST':
-                renderer = createKstScaleRendererPlugin(opts)
-                break
-            case 'FASTK':
-                renderer = createFastkScaleRendererPlugin(opts)
-                break
-            case 'ATR':
-                renderer = createAtrScaleRendererPlugin(opts)
-                break
-            case 'WMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'wma', label: 'WMA', decimals: 2 })
-                break
-            case 'DEMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'dema', label: 'DEMA', decimals: 2 })
-                break
-            case 'TEMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'tema', label: 'TEMA', decimals: 2 })
-                break
-            case 'HMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'hma', label: 'HMA', decimals: 2 })
-                break
-            case 'KAMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'kama', label: 'KAMA', decimals: 2 })
-                break
-            case 'SAR':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'sar', label: 'SAR', decimals: 4 })
-                break
-            case 'SUPERTREND':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'supertrend', label: 'SuperTrend', decimals: 2 })
-                break
-            case 'KELTNER':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'keltner', label: 'Keltner', decimals: 2 })
-                break
-            case 'DONCHIAN':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'donchian', label: 'Donchian', decimals: 2 })
-                break
-            case 'ICHIMOKU':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'ichimoku', label: 'Ichimoku', decimals: 2 })
-                break
-            case 'ROC':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'roc', label: 'ROC', decimals: 2 })
-                break
-            case 'TRIX':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'trix', label: 'TRIX', decimals: 6 })
-                break
-            case 'HV':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'hv', label: 'HV', decimals: 2 })
-                break
-            case 'PARKINSON':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'parkinson', label: 'Parkinson', decimals: 2 })
-                break
-            case 'CHAIKIN_VOL':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'chaikinVol', label: 'ChaikinVol', decimals: 2 })
-                break
-            case 'VMA':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'vma', label: 'VMA', decimals: 0 })
-                break
-            case 'OBV':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'obv', label: 'OBV', decimals: 0 })
-                break
-            case 'PVT':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'pvt', label: 'PVT', decimals: 0 })
-                break
-            case 'VWAP':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'vwap', label: 'VWAP', decimals: 2 })
-                break
-            case 'CMF':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'cmf', label: 'CMF', decimals: 4 })
-                break
-            case 'MFI':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'mfi', label: 'MFI', decimals: 2 })
-                break
-            case 'PIVOT':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'pivot', label: 'Pivot', decimals: 2 })
-                break
-            case 'FIB':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'fib', label: 'Fib', decimals: 4 })
-                break
-            case 'STRUCTURE':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'structure', label: 'Structure', decimals: 2 })
-                break
-            case 'ZONES':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'zones', label: 'Zones', decimals: 2 })
-                break
-            case 'VOLUME_PROFILE':
-                renderer = createIndicatorScaleRendererPlugin({ ...opts, indicatorKey: 'volumeProfile', label: 'VP', decimals: 0 })
-                break
-            default:
-                return
+        const definition = chart.getIndicatorScheduler().getIndicatorMetadata(indicatorId)
+        if (definition?.scaleRendererFactory) {
+            chart.useRenderer(definition.scaleRendererFactory({ ...opts, indicatorId }))
+            return
         }
 
-        chart.useRenderer(renderer)
+        if (definition?.scale) {
+            chart.useRenderer(createIndicatorScaleRendererPlugin({
+                ...opts,
+                indicatorKey: definition.scale.indicatorKey ?? definition.name,
+                label: definition.scale.label ?? definition.displayName,
+                decimals: definition.scale.decimals,
+            }))
+            return
+        }
     }
 
     private mountPaneTitleRenderer(chart: Chart, paneId: string, indicatorId: SubIndicatorType, params: Record<string, unknown>): void {

package/src/semantic/__tests__/controller.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { SemanticChartController, __setDataFetcher, type SemanticChartAdapter } from '../controller'
+import type { SemanticChartConfig } from '../types'
+
+function createConfig(indicators: SemanticChartConfig['indicators']): SemanticChartConfig {
+  return {
+    version: '1.0.0',
+    data: {
+      source: 'baostock',
+      symbol: '600000',
+      exchange: 'SH',
+      startDate: '2025-01-01',
+      endDate: '2025-01-02',
+      period: 'daily',
+      adjust: 'qfq',
+    },
+    indicators,
+  }
+}
+
+function createChartAdapter(): SemanticChartAdapter {
+  return {
+    updateData: vi.fn(),
+    updateRendererConfig: vi.fn(),
+    addIndicator: vi.fn((definitionId: string) => definitionId),
+    removeIndicator: vi.fn(() => true),
+    enableMainIndicator: vi.fn(() => true),
+    disableMainIndicator: vi.fn(() => true),
+    clearSubPanes: vi.fn(),
+    createSubPane: vi.fn(() => true),
+    clearCustomMarkers: vi.fn(),
+    updateCustomMarkers: vi.fn(),
+  }
+}
+
+describe('SemanticChartController', () => {
+  afterEach(() => {
+    __setDataFetcher(null)
+  })
+
+  it('routes semantic sub indicators through registered definitions', async () => {
+    __setDataFetcher(vi.fn(async () => []))
+    const chart = createChartAdapter()
+    const controller = new SemanticChartController(chart)
+
+    const result = await controller.applyConfig(
+      createConfig({
+        sub: [
+          { type: 'VOLUME', enabled: true },
+          { type: 'RSI', enabled: true, params: { period1: 7 } },
+          { type: 'MACD', enabled: false, params: { fast: 8 } },
+        ],
+      }),
+    )
+
+    expect(result).toEqual({ success: true })
+    expect(chart.clearSubPanes).toHaveBeenCalledTimes(1)
+    expect(chart.createSubPane).toHaveBeenCalledTimes(2)
+    expect(chart.createSubPane).toHaveBeenCalledWith('VOLUME_0', 'VOLUME', undefined)
+    expect(chart.createSubPane).toHaveBeenCalledWith('RSI_0', 'RSI', { period1: 7 })
+  })
+
+  it('routes semantic main indicators through chart main indicator API', async () => {
+    __setDataFetcher(vi.fn(async () => []))
+    const chart = createChartAdapter()
+    const controller = new SemanticChartController(chart)
+
+    const result = await controller.applyConfig(
+      createConfig({
+        main: [
+          { type: 'BOLL', enabled: true, params: { period: 21, multiplier: 2.5 } },
+          { type: 'MA', enabled: false, params: { periods: [5, 20] } },
+        ],
+      }),
+    )
+
+    expect(result).toEqual({ success: true })
+    expect(chart.addIndicator).toHaveBeenCalledWith('BOLL', 'main', { period: 21, multiplier: 2.5 })
+    expect(chart.removeIndicator).toHaveBeenCalledWith('MA')
+    expect(chart.enableMainIndicator).not.toHaveBeenCalled()
+    expect(chart.disableMainIndicator).not.toHaveBeenCalled()
+    expect(chart.updateRendererConfig).not.toHaveBeenCalledWith('boll', expect.anything())
+  })
+})

package/src/semantic/controller.ts

@@ -1,6 +1,9 @@
 import { EventBus } from '../plugin/EventBus'
 import type { CustomMarkerEntity } from '../engine/marker/registry'
 import { SemanticConfigValidator } from './validator'
+import { getBuiltinIndicatorDefinitions } from '../engine/indicators/registerBuiltins'
+import { getRegisteredIndicatorDefinition } from '../engine/indicators/indicatorDefinitionRegistry'
+import type { IndicatorMetadata } from '../engine/indicators/indicatorMetadata'
 import type {
   SemanticChartConfig,
   ApplyResult,
@@ -27,6 +30,21 @@ export type DataFetcher = (
 
 let _dataFetcher: DataFetcher | null = null
 
+function normalizeIndicatorId(id: string): string {
+  return id.trim().toLowerCase().replace(/[^a-z0-9]/g, '')
+}
+
+function getSemanticIndicatorDefinition(type: string): IndicatorMetadata | undefined {
+  const registered = getRegisteredIndicatorDefinition(type)
+  if (registered) return registered
+
+  const normalizedType = normalizeIndicatorId(type)
+  return getBuiltinIndicatorDefinitions().find((definition) => {
+    const candidates = [definition.name, definition.displayName, ...(definition.aliases ?? [])]
+    return candidates.some((candidate) => normalizeIndicatorId(candidate) === normalizedType)
+  })
+}
+
 export function __setDataFetcher(fetcher: DataFetcher | null): void {
   _dataFetcher = fetcher
 }
@@ -44,6 +62,10 @@ async function getDataFetcher(): Promise<DataFetcher> {
 export interface SemanticChartAdapter {
   updateData(data: ReadonlyArray<KLineData>): void
   updateRendererConfig(name: string, config: Record<string, unknown>): void
+  addIndicator?(definitionId: string, role: 'main' | 'sub', params?: Record<string, unknown>): string | null
+  removeIndicator?(instanceId: string): boolean
+  enableMainIndicator?(indicatorId: string, params?: Record<string, number | boolean | string>): boolean
+  disableMainIndicator?(indicatorId: string): boolean
   clearSubPanes(): void
   createSubPane(paneId: string, indicatorId: CoreSubIndicatorType, params?: Record<string, unknown>): boolean
   clearCustomMarkers(): void
@@ -94,7 +116,35 @@ export class SemanticChartController {
     this.events.off(event, handler)
   }
 
+  /**
+   * 仅注册指标配置，不获取/更新数据。
+   * 用于 performanceTest10kKlines 等场景：数据由外部提供，语义控制器只管指标。
+   */
+  applyIndicatorsOnly(config: SemanticChartConfig): ApplyResult {
+    try {
+      if (config.indicators) {
+        this.applyIndicators(config.indicators.main, config.indicators.sub)
+      }
+      if (config.markers) {
+        this.applyMarkers(config.markers.customMarkers, config.data.period)
+      }
+      this.events.emit('config:ready', undefined)
+      return { success: true }
+    } catch (error) {
+      this.events.emit('config:error', error)
+      return {
+        success: false,
+        errors: [error instanceof Error ? error.message : String(error)],
+      }
+    }
+  }
+
   private async doApplyConfig(config: SemanticChartConfig): Promise<void> {
+    // 先注册指标（同步），确保 scheduler 首次 applyResults 时指标已在 registry
+    if (config.indicators) {
+      this.applyIndicators(config.indicators.main, config.indicators.sub)
+    }
+
     const fetcher = await getDataFetcher()
     const data = await fetcher(config.data.source, {
       symbol: config.data.symbol,
@@ -105,10 +155,6 @@ export class SemanticChartController {
     })
     this.chart.updateData(data)
 
-    if (config.indicators) {
-      this.applyIndicators(config.indicators.main, config.indicators.sub)
-    }
-
     if (config.markers) {
       this.applyMarkers(config.markers.customMarkers, config.data.period)
     }
@@ -121,21 +167,24 @@ export class SemanticChartController {
   private applyIndicators(main?: MainIndicatorConfig[], sub?: SubIndicatorConfig[]): void {
     if (main) {
       for (const indicator of main) {
-        if (!indicator.enabled) continue
-        switch (indicator.type) {
-          case 'MA':
-            this.applyMAIndicator(indicator)
-            break
-          case 'BOLL':
-            this.applyBOLLIndicator(indicator)
-            break
-          case 'EXPMA':
-            this.applyEXPMAIndicator(indicator)
-            break
-          case 'ENE':
-            this.applyENEIndicator(indicator)
-            break
+        if (!indicator.enabled) {
+          if (!this.chart.removeIndicator?.(indicator.type)) {
+            this.chart.disableMainIndicator?.(indicator.type)
+          }
+          continue
+        }
+        const added = this.chart.addIndicator?.(indicator.type, 'main', indicator.params as Record<string, unknown>)
+        if (added) {
+          continue
+        }
+        const enabled = this.chart.enableMainIndicator?.(
+            indicator.type,
+            indicator.params as Record<string, number | boolean | string>,
+          )
+        if (enabled) {
+          continue
         }
+        getSemanticIndicatorDefinition(indicator.type)?.semantic?.apply?.(this.chart, indicator)
       }
     }
 
@@ -148,57 +197,12 @@ export class SemanticChartController {
     }
   }
 
-  private applyMAIndicator(indicator: { type: 'MA'; enabled: boolean; params?: { periods: number[] } }): void {
-    const periods = indicator.params?.periods || [5, 10, 20, 30, 60]
-    const maFlags: { ma5?: boolean; ma10?: boolean; ma20?: boolean; ma30?: boolean; ma60?: boolean } = {}
-    for (const p of periods) {
-      if (p === 5) maFlags.ma5 = true
-      else if (p === 10) maFlags.ma10 = true
-      else if (p === 20) maFlags.ma20 = true
-      else if (p === 30) maFlags.ma30 = true
-      else if (p === 60) maFlags.ma60 = true
-    }
-    this.chart.updateRendererConfig('ma', maFlags)
-  }
-
-  private applyBOLLIndicator(indicator: {
-    type: 'BOLL'
-    enabled: boolean
-    params?: { period?: number; multiplier?: number }
-  }): void {
-    this.chart.updateRendererConfig('boll', {
-      period: indicator.params?.period || 20,
-      multiplier: indicator.params?.multiplier || 2,
-    })
-  }
-
-  private applyEXPMAIndicator(indicator: {
-    type: 'EXPMA'
-    enabled: boolean
-    params?: { fastPeriod?: number; slowPeriod?: number }
-  }): void {
-    this.chart.updateRendererConfig('expma', {
-      fastPeriod: indicator.params?.fastPeriod || 12,
-      slowPeriod: indicator.params?.slowPeriod || 50,
-    })
-  }
-
-  private applyENEIndicator(indicator: {
-    type: 'ENE'
-    enabled: boolean
-    params?: { period?: number; deviation?: number }
-  }): void {
-    this.chart.updateRendererConfig('ene', {
-      period: indicator.params?.period || 10,
-      deviation: indicator.params?.deviation || 11,
-    })
-  }
-
   private applySubIndicator(indicator: SubIndicatorConfig): void {
     if (!indicator.enabled) return
     const { type, params } = indicator
     const paneId = `${type}_0`
-    const success = this.chart.createSubPane(paneId, type as CoreSubIndicatorType, params)
+    const indicatorId = type
+    const success = this.chart.createSubPane(paneId, indicatorId as CoreSubIndicatorType, params)
     if (!success) {
       console.warn(`[Semantic] Failed to create sub pane for ${type}`)
     }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.7.9"
+export const VERSION = "0.7.10"