@363045841yyt/klinechart-core 0.7.3

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

@@ -0,0 +1,124 @@
+import type { RendererPluginWithHost, RenderContext, PluginHost } from '../../../plugin'
+import { RENDERER_PRIORITY } from '../../../plugin'
+import type { HVRenderState } from '../../indicators/hvState'
+import { createHVStateKey } from '../../indicators/hvState'
+import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
+import { resolveStateKey } from '../../indicators/indicatorMetadata'
+import type { IndicatorScheduler } from '../../indicators/scheduler'
+
+const HV_COLOR = '#7c3aed'
+
+type LinePoint = { x: number; y: number }
+
+function getHVStateKey(host: PluginHost | null, paneId: string): string | null {
+    const scheduler = host?.getService<IndicatorScheduler>('indicatorScheduler')
+    if (!scheduler) {
+        console.warn(`[HVRenderer] Scheduler not available via service locator`)
+        return null
+    }
+    const meta = scheduler.getIndicatorMetadata('hv')
+    if (!meta) {
+        console.warn(`[HVRenderer] Indicator metadata for 'hv' not found, skip rendering`)
+        return null
+    }
+    return resolveStateKey(meta.stateKey, paneId)
+}
+
+export function createHVRendererPlugin(options: { paneId?: string } = {}): RendererPluginWithHost {
+    const { paneId = 'sub_HV' } = options
+    let pluginHost: PluginHost | null = null
+
+    function resolveKey(): string | null {
+        return getHVStateKey(pluginHost, paneId)
+    }
+
+    return {
+        name: `hv_${paneId}`,
+        version: '1.1.0',
+        description: 'HV 历史波动率渲染器（WebGL + Canvas2D 回退）',
+        debugName: 'HV',
+        paneId,
+        priority: RENDERER_PRIORITY.MAIN,
+        onInstall(host) { pluginHost = host },
+        getDeclaredNamespaces() { const key = resolveKey(); return key ? [key] : [] },
+        draw(context: RenderContext) {
+            const { ctx, pane, range, scrollLeft, kLineCenters, lineWebGLSurface } = context
+            const stateKey = resolveKey()
+            if (!stateKey) return
+            const state = pluginHost?.getSharedState<HVRenderState>(stateKey)
+            if (!state || !state.params.showHV || state.visibleMin > state.visibleMax) return
+
+            const { valueMin, valueMax, series } = state
+            const displayRange = pane.yAxis.getDisplayRange({ minPrice: valueMin, maxPrice: valueMax })
+            const displayMin = displayRange.minPrice
+            const displayMax = displayRange.maxPrice
+            const displayValueRange = displayMax - displayMin || 1
+            const paneH = pane.height
+            const invRange = paneH / displayValueRange
+            const rangeStart = range.start
+
+            const drawEnd = Math.min(range.end, series.length)
+            const points: LinePoint[] = []
+            for (let i = range.start; i < drawEnd; i++) {
+                const value = series[i]
+                if (value === undefined) continue
+                const centerX = kLineCenters[i - rangeStart]
+                if (centerX === undefined) continue
+                points.push({ x: centerX, y: paneH - (value - displayMin) * invRange })
+            }
+
+            if (points.length < 2) return
+
+            const enableWebGL = context.settings?.enableWebGLRendering !== false
+            let usedWebGL = false
+            if (enableWebGL && lineWebGLSurface?.isAvailable()) {
+                const allOk = lineWebGLSurface.drawLineStrips(
+                    [{ points, width: 1, color: HV_COLOR }],
+                    scrollLeft,
+                )
+                if (allOk) {
+                    usedWebGL = true
+                    lineWebGLSurface.compositeTo(ctx, { imageSmoothingEnabled: false })
+                }
+            }
+
+            if (usedWebGL) return
+
+            ctx.save()
+            ctx.translate(-scrollLeft, 0)
+            ctx.strokeStyle = HV_COLOR
+            ctx.lineWidth = 1
+            ctx.lineJoin = 'round'
+            ctx.lineCap = 'round'
+            ctx.beginPath()
+            ctx.moveTo(points[0]!.x, points[0]!.y)
+            for (let i = 1; i < points.length; i++) {
+                ctx.lineTo(points[i]!.x, points[i]!.y)
+            }
+            ctx.stroke()
+            ctx.restore()
+        },
+        getConfig() {
+            const stateKey = resolveKey()
+            if (!stateKey) return {}
+            const state = pluginHost?.getSharedState<HVRenderState>(stateKey)
+            return state?.params ?? {}
+        },
+        setConfig() {},
+    }
+}
+
+@Indicator({
+    name: 'hv',
+    displayName: 'HV',
+    category: 'oscillator',
+    stateKey: createHVStateKey,
+    defaultPaneId: 'sub_HV',
+    paneIdField: 'hvPaneId',
+    applyResult: (host, state, paneId) => {
+        host.setSharedState(createHVStateKey(paneId), state as any, 'indicator_scheduler')
+    },
+})
+class HVIndicatorDefinition {
+    static rendererFactory = createHVRendererPlugin
+}

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

@@ -0,0 +1,182 @@
+import type { RendererPluginWithHost, RenderContext, PluginHost } from '../../../plugin'
+import { RENDERER_PRIORITY } from '../../../plugin'
+import type { IchimokuRenderState } from '../../indicators/ichimokuState'
+import { createIchimokuStateKey } from '../../indicators/ichimokuState'
+import { Indicator } from '../../indicators/indicatorDefinitionRegistry'
+import { resolveStateKey } from '../../indicators/indicatorMetadata'
+import type { IndicatorScheduler } from '../../indicators/scheduler'
+
+const TENKAN_COLOR = '#dc2626'
+const KIJUN_COLOR = '#2563eb'
+const SPAN_A_COLOR = '#16a34a'
+const SPAN_B_COLOR = '#dc2626'
+const CHIKOU_COLOR = '#7c3aed'
+const CLOUD_BULL = 'rgba(34, 197, 94, 0.15)'
+const CLOUD_BEAR = 'rgba(239, 68, 68, 0.15)'
+
+type Point = { x: number; y: number }
+
+export interface IchimokuRendererOptions {
+    paneId?: string
+}
+
+function getIchimokuStateKey(host: PluginHost | null, paneId: string): string | null {
+    const scheduler = host?.getService<IndicatorScheduler>('indicatorScheduler')
+    if (!scheduler) {
+        console.warn('[IchimokuRenderer] Scheduler not available via service locator')
+        return null
+    }
+    const meta = scheduler.getIndicatorMetadata('ichimoku')
+    if (!meta) {
+        console.warn('[IchimokuRenderer] Indicator metadata for \'ichimoku\' not found, skip rendering')
+        return null
+    }
+    return resolveStateKey(meta.stateKey, paneId)
+}
+
+export function createIchimokuRendererPlugin(options: IchimokuRendererOptions = {}): RendererPluginWithHost {
+    const { paneId = 'main' } = options
+    let pluginHost: PluginHost | null = null
+
+    function resolveKey(): string | null {
+        return getIchimokuStateKey(pluginHost, paneId)
+    }
+
+    return {
+        name: `ichimoku_${paneId}`,
+        version: '1.1.0',
+        description: '一目均衡表渲染器（WebGL 线 + Canvas2D 云图）',
+        debugName: 'Ichimoku',
+        paneId,
+        priority: RENDERER_PRIORITY.MAIN,
+
+        onInstall(host: PluginHost) { pluginHost = host },
+        getDeclaredNamespaces() { const key = resolveKey(); return key ? [key] : [] },
+
+        draw(context: RenderContext) {
+            const { ctx, pane, range, scrollLeft, kLineCenters, lineWebGLSurface } = context
+            const stateKey = resolveKey()
+            if (!stateKey) return
+            const state = pluginHost?.getSharedState<IchimokuRenderState>(stateKey)
+            if (!state || state.visibleMin > state.visibleMax) return
+            const { params, series } = state
+
+            const toY = (price: number) => pane.yAxis.priceToY(price)
+            const rangeStart = range.start
+
+            const tenkanPts: Point[] = []
+            const kijunPts: Point[] = []
+            const spanAPts: Point[] = []
+            const spanBPts: Point[] = []
+            const chikouPts: Point[] = []
+            const cloudSegs: { x: number; ya: number; yb: number; bull: boolean }[] = []
+
+            const drawEnd = Math.min(range.end, series.length)
+            for (let i = range.start; i < drawEnd; i++) {
+                const p = series[i]
+                if (!p) continue
+                const centerX = kLineCenters[i - rangeStart]
+                if (centerX === undefined) continue
+                if (params.showTenkan && p.tenkan !== undefined) tenkanPts.push({ x: centerX, y: toY(p.tenkan) })
+                if (params.showKijun && p.kijun !== undefined) kijunPts.push({ x: centerX, y: toY(p.kijun) })
+                if (params.showSpanA && p.spanA !== undefined) spanAPts.push({ x: centerX, y: toY(p.spanA) })
+                if (params.showSpanB && p.spanB !== undefined) spanBPts.push({ x: centerX, y: toY(p.spanB) })
+                if (params.showChikou && p.chikou !== undefined) chikouPts.push({ x: centerX, y: toY(p.chikou) })
+                if (params.showCloud && p.spanA !== undefined && p.spanB !== undefined) {
+                    cloudSegs.push({ x: centerX, ya: toY(p.spanA), yb: toY(p.spanB), bull: p.spanA > p.spanB })
+                }
+            }
+
+            // Cloud fill (Canvas2D only)
+            if (params.showCloud && cloudSegs.length >= 2) {
+                ctx.save()
+                ctx.translate(-scrollLeft, 0)
+                fillCloud(ctx, cloudSegs)
+                ctx.restore()
+            }
+
+            // Lines (WebGL + Canvas2D fallback)
+            const lines: Array<{ points: Point[]; width: number; color: string }> = []
+            if (tenkanPts.length >= 2) lines.push({ points: tenkanPts, width: 1, color: TENKAN_COLOR })
+            if (kijunPts.length >= 2) lines.push({ points: kijunPts, width: 1, color: KIJUN_COLOR })
+            if (spanAPts.length >= 2) lines.push({ points: spanAPts, width: 1, color: SPAN_A_COLOR })
+            if (spanBPts.length >= 2) lines.push({ points: spanBPts, width: 1, color: SPAN_B_COLOR })
+            if (chikouPts.length >= 2) lines.push({ points: chikouPts, width: 1, color: CHIKOU_COLOR })
+
+            const enableWebGL = context.settings?.enableWebGLRendering !== false
+            let usedWebGL = false
+            if (enableWebGL && lineWebGLSurface?.isAvailable()) {
+                const allOk = lines.length > 0 && lineWebGLSurface.drawLineStrips(lines, scrollLeft)
+                if (allOk) {
+                    usedWebGL = true
+                    lineWebGLSurface.compositeTo(ctx, { imageSmoothingEnabled: false })
+                }
+            }
+
+            if (usedWebGL) return
+
+            ctx.save()
+            ctx.translate(-scrollLeft, 0)
+            ctx.lineWidth = 1
+            ctx.lineJoin = 'round'
+            ctx.lineCap = 'round'
+            drawLine(ctx, tenkanPts, TENKAN_COLOR)
+            drawLine(ctx, kijunPts, KIJUN_COLOR)
+            drawLine(ctx, spanAPts, SPAN_A_COLOR)
+            drawLine(ctx, spanBPts, SPAN_B_COLOR)
+            drawLine(ctx, chikouPts, CHIKOU_COLOR)
+            ctx.restore()
+        },
+
+        getConfig() {
+            const stateKey = resolveKey()
+            if (!stateKey) return {}
+            const state = pluginHost?.getSharedState<IchimokuRenderState>(stateKey)
+            return state?.params ?? {}
+        },
+        setConfig() {},
+    }
+}
+
+function drawLine(ctx: CanvasRenderingContext2D, pts: Point[], color: string): void {
+    if (pts.length < 2) return
+    ctx.strokeStyle = color
+    ctx.beginPath()
+    ctx.moveTo(pts[0]!.x, pts[0]!.y)
+    for (let i = 1; i < pts.length; i++) ctx.lineTo(pts[i]!.x, pts[i]!.y)
+    ctx.stroke()
+}
+
+function fillCloud(
+    ctx: CanvasRenderingContext2D,
+    segs: { x: number; ya: number; yb: number; bull: boolean }[],
+): void {
+    for (let i = 0; i < segs.length - 1; i++) {
+        const a = segs[i]!
+        const b = segs[i + 1]!
+        ctx.fillStyle = a.bull ? CLOUD_BULL : CLOUD_BEAR
+        ctx.beginPath()
+        ctx.moveTo(a.x, a.ya)
+        ctx.lineTo(b.x, b.ya)
+        ctx.lineTo(b.x, b.yb)
+        ctx.lineTo(a.x, a.yb)
+        ctx.closePath()
+        ctx.fill()
+    }
+}
+
+@Indicator({
+    name: 'ichimoku',
+    displayName: 'Ichimoku',
+    category: 'main',
+    stateKey: createIchimokuStateKey,
+    defaultPaneId: 'main',
+    paneIdField: 'ichimokuPaneId',
+    allowMainPane: true,
+    applyResult: (host, state, paneId) => {
+        host.setSharedState(createIchimokuStateKey(paneId), state as any, 'indicator_scheduler')
+    },
+})
+class IchimokuDefinition {
+    static rendererFactory = createIchimokuRendererPlugin
+}

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

@@ -0,0 +1,241 @@
+/**
+ * 指标渲染器导出入口
+ */
+
+import type { RendererPlugin } from '../../../plugin'
+import { createVolumeRendererPlugin } from '../subVolume'
+
+// MA 均线
+export { createMARendererPlugin, type MAFlags } from './ma'
+
+// BOLL 布林带
+export { createBOLLRendererPlugin } from './boll'
+
+// EXPMA 指数平滑移动平均线
+export { createEXPMARendererPlugin } from './expma'
+
+// ENE 轨道线
+export { createENERendererPlugin } from './ene'
+
+// 主图指标图例（统一管理 MA、BOLL 等）
+export { createMainIndicatorLegendRendererPlugin } from './mainIndicatorLegend'
+
+// MACD
+export { createMACDRendererPlugin, calcMACDAtIndex, type MACDConfig, type MACDRendererOptions, getMACDTitleInfo } from './macd'
+export { createMACDLegendRendererPlugin, type MACDLegendOptions } from './macdLegend'
+
+// RSI 相对强弱指标
+export { createRSIRendererPlugin, type RSIRendererOptions, getRSITitleInfo } from './rsi'
+
+// CCI 顺势指标
+export { createCCIRendererPlugin, type CCIRendererOptions, getCCITitleInfo } from './cci'
+
+// STOCH 随机指标
+export { createSTOCHRendererPlugin, type STOCHRendererOptions, getSTOCHTitleInfo } from './stoch'
+
+// MOM 动量指标
+export { createMOMRendererPlugin, type MOMRendererOptions, getMOMTitleInfo } from './mom'
+
+// WMSR 威廉指标
+export { createWMSRRendererPlugin, type WMSRRendererOptions, getWMSRTitleInfo } from './wmsr'
+
+// KST 确知指标
+export { createKSTRendererPlugin, type KSTRendererOptions, getKSTTitleInfo } from './kst'
+
+// FASTK 快速随机指标
+export { createFASTKRendererPlugin, type FASTKRendererOptions, getFASTKTitleInfo } from './fastk'
+
+// ATR 平均真实波幅
+export { createATRRendererPlugin, type ATRRendererOptions, getATRTitleInfo } from './atr'
+
+// WMA 加权移动平均
+export { createWMARendererPlugin } from './wma'
+// DEMA 双指数移动平均
+export { createDEMARendererPlugin } from './dema'
+// TEMA 三指数移动平均
+export { createTEMARendererPlugin } from './tema'
+// HMA 赫尔移动平均
+export { createHMARendererPlugin } from './hma'
+// KAMA 考夫曼自适应移动平均
+export { createKAMARendererPlugin } from './kama'
+// SAR 抛物线转向
+export { createSARRendererPlugin } from './sar'
+// SuperTrend 超级趋势
+export { createSuperTrendRendererPlugin } from './supertrend'
+// Keltner 肯特纳通道
+export { createKeltnerRendererPlugin } from './keltner'
+// Donchian 唐奇安通道
+export { createDonchianRendererPlugin } from './donchian'
+// Ichimoku 一目均衡表
+export { createIchimokuRendererPlugin } from './ichimoku'
+// ROC 变化率
+export { createROCRendererPlugin } from './roc'
+// TRIX 三重指数平滑平均
+export { createTRIXRendererPlugin } from './trix'
+// HV 历史波动率
+export { createHVRendererPlugin } from './hv'
+// Parkinson 帕金森波动率
+export { createParkinsonRendererPlugin } from './parkinson'
+// Chaikin Vol 蔡金波动率
+export { createChaikinVolRendererPlugin } from './chaikinVol'
+// VMA 成交量移动平均
+export { createVMARendererPlugin } from './vma'
+// OBV 能量潮
+export { createOBVRendererPlugin } from './obv'
+// PVT 价量趋势
+export { createPVTRendererPlugin } from './pvt'
+// VWAP 成交量加权均价
+export { createVWAPRendererPlugin } from './vwap'
+// CMF 蔡金资金流
+export { createCMFRendererPlugin } from './cmf'
+// MFI 资金流量指数
+export { createMFIRendererPlugin } from './mfi'
+// Pivot Points 枢轴点
+export { createPivotRendererPlugin } from './pivot'
+// Fibonacci 斐波那契
+export { createFibRendererPlugin } from './fib'
+// SMC Structure 结构
+export { createStructureRendererPlugin } from './structure'
+// SMC Zones 区域
+export { createZonesRendererPlugin } from './zones'
+// Volume Profile 成交量分布
+export { createVolumeProfileRendererPlugin } from './volumeProfile'
+
+/**
+ * 副图指标类型
+ */
+export type SubIndicatorType = 'VOLUME' | 'MACD' | 'RSI' | 'CCI' | 'STOCH' | 'MOM' | 'WMSR' | 'KST' | 'FASTK' | 'ATR'
+    | 'WMA' | 'DEMA' | 'TEMA' | 'HMA' | 'KAMA' | 'SAR' | 'SUPERTREND' | 'KELTNER' | 'DONCHIAN' | 'ICHIMOKU'
+    | 'ROC' | 'TRIX' | 'HV' | 'PARKINSON' | 'CHAIKIN_VOL' | 'VMA' | 'OBV' | 'PVT' | 'VWAP'
+    | 'CMF' | 'MFI' | 'PIVOT' | 'FIB' | 'STRUCTURE' | 'ZONES' | 'VOLUME_PROFILE'
+
+/**
+ * 渲染器工厂选项
+ */
+export interface IndicatorRendererOptions {
+    /** 指标类型 */
+    indicatorId: SubIndicatorType
+    /** 目标 pane ID */
+    paneId: string
+}
+
+// 导入各个创建函数用于工厂函数
+import { createMACDRendererPlugin } from './macd'
+import { createRSIRendererPlugin } from './rsi'
+import { createCCIRendererPlugin } from './cci'
+import { createSTOCHRendererPlugin } from './stoch'
+import { createMOMRendererPlugin } from './mom'
+import { createWMSRRendererPlugin } from './wmsr'
+import { createKSTRendererPlugin } from './kst'
+import { createFASTKRendererPlugin } from './fastk'
+import { createATRRendererPlugin } from './atr'
+import { createWMARendererPlugin } from './wma'
+import { createDEMARendererPlugin } from './dema'
+import { createTEMARendererPlugin } from './tema'
+import { createHMARendererPlugin } from './hma'
+import { createKAMARendererPlugin } from './kama'
+import { createSARRendererPlugin } from './sar'
+import { createSuperTrendRendererPlugin } from './supertrend'
+import { createKeltnerRendererPlugin } from './keltner'
+import { createDonchianRendererPlugin } from './donchian'
+import { createIchimokuRendererPlugin } from './ichimoku'
+import { createROCRendererPlugin } from './roc'
+import { createTRIXRendererPlugin } from './trix'
+import { createHVRendererPlugin } from './hv'
+import { createParkinsonRendererPlugin } from './parkinson'
+import { createChaikinVolRendererPlugin } from './chaikinVol'
+import { createVMARendererPlugin } from './vma'
+import { createOBVRendererPlugin } from './obv'
+import { createPVTRendererPlugin } from './pvt'
+import { createVWAPRendererPlugin } from './vwap'
+import { createCMFRendererPlugin } from './cmf'
+import { createMFIRendererPlugin } from './mfi'
+import { createPivotRendererPlugin } from './pivot'
+import { createFibRendererPlugin } from './fib'
+import { createStructureRendererPlugin } from './structure'
+import { createZonesRendererPlugin } from './zones'
+import { createVolumeProfileRendererPlugin } from './volumeProfile'
+
+/**
+ * 创建副图指标渲染器（统一工厂函数）
+ */
+export function createSubIndicatorRenderer(options: IndicatorRendererOptions): RendererPlugin {
+    const { indicatorId, paneId } = options
+
+    switch (indicatorId) {
+        case 'VOLUME':
+            return createVolumeRendererPlugin({ paneId })
+        case 'MACD':
+            return createMACDRendererPlugin({ paneId })
+        case 'RSI':
+            return createRSIRendererPlugin({ paneId })
+        case 'CCI':
+            return createCCIRendererPlugin({ paneId })
+        case 'STOCH':
+            return createSTOCHRendererPlugin({ paneId })
+        case 'MOM':
+            return createMOMRendererPlugin({ paneId })
+        case 'WMSR':
+            return createWMSRRendererPlugin({ paneId })
+        case 'KST':
+            return createKSTRendererPlugin({ paneId })
+        case 'FASTK':
+            return createFASTKRendererPlugin({ paneId })
+        case 'ATR':
+            return createATRRendererPlugin({ paneId })
+        case 'WMA':
+            return createWMARendererPlugin({ paneId })
+        case 'DEMA':
+            return createDEMARendererPlugin({ paneId })
+        case 'TEMA':
+            return createTEMARendererPlugin({ paneId })
+        case 'HMA':
+            return createHMARendererPlugin({ paneId })
+        case 'KAMA':
+            return createKAMARendererPlugin({ paneId })
+        case 'SAR':
+            return createSARRendererPlugin({ paneId })
+        case 'SUPERTREND':
+            return createSuperTrendRendererPlugin({ paneId })
+        case 'KELTNER':
+            return createKeltnerRendererPlugin({ paneId })
+        case 'DONCHIAN':
+            return createDonchianRendererPlugin({ paneId })
+        case 'ICHIMOKU':
+            return createIchimokuRendererPlugin({ paneId })
+        case 'ROC':
+            return createROCRendererPlugin({ paneId })
+        case 'TRIX':
+            return createTRIXRendererPlugin({ paneId })
+        case 'HV':
+            return createHVRendererPlugin({ paneId })
+        case 'PARKINSON':
+            return createParkinsonRendererPlugin({ paneId })
+        case 'CHAIKIN_VOL':
+            return createChaikinVolRendererPlugin({ paneId })
+        case 'VMA':
+            return createVMARendererPlugin({ paneId })
+        case 'OBV':
+            return createOBVRendererPlugin({ paneId })
+        case 'PVT':
+            return createPVTRendererPlugin({ paneId })
+        case 'VWAP':
+            return createVWAPRendererPlugin({ paneId })
+        case 'CMF':
+            return createCMFRendererPlugin({ paneId })
+        case 'MFI':
+            return createMFIRendererPlugin({ paneId })
+        case 'PIVOT':
+            return createPivotRendererPlugin({ paneId })
+        case 'FIB':
+            return createFibRendererPlugin({ paneId })
+        case 'STRUCTURE':
+            return createStructureRendererPlugin({ paneId })
+        case 'ZONES':
+            return createZonesRendererPlugin({ paneId })
+        case 'VOLUME_PROFILE':
+            return createVolumeProfileRendererPlugin({ paneId })
+        default:
+            throw new Error(`Unknown indicator: ${indicatorId}`)
+    }
+}