@363045841yyt/klinechart-core 0.8.14 → 0.9.0-alpha.0

package/src/engine/__tests__/chart.dpr.test.ts

@@ -274,6 +274,93 @@ describe('Chart DPR pipeline', () => {
 
     await chart.destroy()
   })
+
+  it('routes custom markers through kernel and clears position cache', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    const manager = chart.getMarkerManager()
+    const scheduleDrawSpy = vi.spyOn(chart, 'scheduleDraw')
+    const clearCacheSpy = vi.spyOn(manager, 'clearPositionCache')
+
+    const marker = {
+      id: 'm1',
+      date: '2025-01-15',
+      timestamp: 1,
+      shape: 'circle' as const,
+    }
+
+    chart.updateCustomMarkers([marker])
+    expect(manager.getCustomMarkers().map((m) => m.id)).toEqual(['m1'])
+    expect(clearCacheSpy).toHaveBeenCalled()
+    expect(scheduleDrawSpy).toHaveBeenCalled()
+
+    manager.setCustomMarkerPosition('m1', 10, 20, 12, 'circle')
+    expect(manager.hitTestCustomMarker(10, 20)?.id).toBe('m1')
+
+    clearCacheSpy.mockClear()
+    scheduleDrawSpy.mockClear()
+    chart.clearCustomMarkers()
+    expect(manager.getCustomMarkers()).toEqual([])
+    expect(clearCacheSpy).toHaveBeenCalledTimes(1)
+    expect(scheduleDrawSpy).toHaveBeenCalled()
+    expect(manager.hitTestCustomMarker(10, 20)).toBeNull()
+
+    clearCacheSpy.mockClear()
+    chart.registerCustomMarker({ ...marker, id: 'm2', shape: 'flag' })
+    expect(manager.getCustomMarkers().map((m) => m.id)).toEqual(['m2'])
+    expect(clearCacheSpy).toHaveBeenCalledTimes(1)
+
+    await chart.destroy()
+  })
+
+  it('routes drawings through kernel for store projection', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    const store = chart.getDrawingStore()
+    const scheduleDrawSpy = vi.spyOn(chart, 'scheduleDraw')
+    const drawing = {
+      id: 'd1',
+      kind: 'trend-line' as const,
+      paneId: 'main',
+      visible: true,
+      anchors: [],
+      params: {},
+      style: { stroke: '#2962ff' },
+    }
+
+    chart.setDrawings([drawing])
+    expect(chart.drawings.peek().map((d) => d.id)).toEqual(['d1'])
+    expect(store.getAll().map((d) => d.id)).toEqual(['d1'])
+    expect(scheduleDrawSpy).toHaveBeenCalled()
+
+    chart.setSelectedDrawingId('d1')
+    expect(store.getSelectedId()).toBe('d1')
+
+    scheduleDrawSpy.mockClear()
+    chart.setDrawings([])
+    expect(store.getAll()).toEqual([])
+    expect(store.getSelectedId()).toBeNull()
+    expect(scheduleDrawSpy).toHaveBeenCalled()
+
+    await chart.destroy()
+  })
+
+  it('projectState does not commitLayout back to kernel', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    const commitSpy = vi.spyOn(chart.kernel.pane.actions, 'commitLayout')
+    commitSpy.mockClear()
+
+    const layout = (chart as unknown as { layoutManager: { projectState: Function } })
+      .layoutManager
+    layout.projectState(
+      [
+        { id: 'main', ratio: 0.7, role: 'price', visible: true },
+        { id: 'MACD_0', ratio: 0.3, role: 'indicator', visible: true },
+      ],
+      { main: 0.7, MACD_0: 0.3 },
+    )
+
+    expect(commitSpy).not.toHaveBeenCalled()
+    await chart.destroy()
+  })
 })
 
 describe('Chart pane layout regressions', () => {
@@ -323,10 +410,11 @@ describe('Chart pane layout regressions', () => {
     const specs = chart.getPaneLayoutSpecs().filter((pane) => pane.visible !== false)
     expect(specs).toHaveLength(3)
 
+    // 公共读对齐 kernel SSOT（createSubPane 3:1:1 → 0.6:0.2:0.2）
     const byId = new Map(specs.map((pane) => [pane.id, pane]))
-    expect(byId.get('main')?.ratio ?? 0).toBeCloseTo(7 / 12, 6)
-    expect(byId.get('MACD_0')?.ratio ?? 0).toBeCloseTo(5 / 24, 6)
-    expect(byId.get('RSI_0')?.ratio ?? 0).toBeCloseTo(5 / 24, 6)
+    expect(byId.get('main')?.ratio ?? 0).toBeCloseTo(0.6, 6)
+    expect(byId.get('MACD_0')?.ratio ?? 0).toBeCloseTo(0.2, 6)
+    expect(byId.get('RSI_0')?.ratio ?? 0).toBeCloseTo(0.2, 6)
 
     await chart.destroy()
   })
@@ -385,6 +473,83 @@ describe('Chart pane layout regressions', () => {
     await chart.destroy()
   })
 
+  it('updateSettings rightAxisType writes paneScaleTypes then projects', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    chart.resize()
+    chart.updateSettings({ rightAxisType: 'log' })
+    expect(chart.kernel.pane.readonly.paneScaleTypes.peek().get('main')).toBe('log')
+    const main = chart.getPaneRenderers()[0]?.getPane()
+    expect(main?.yAxis.getScaleType()).toBe('log')
+    await chart.destroy()
+  })
+
+  it('createSubPane seeds scale from settings and projects', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    chart.resize()
+    chart.updateSettings({ rightAxisType: 'log' })
+    expect(chart.createSubPane('MACD_0', 'MACD')).toBe(true)
+    expect(chart.kernel.pane.readonly.paneScaleTypes.peek().get('main')).toBe('log')
+    expect(chart.kernel.pane.readonly.paneScaleTypes.peek().get('MACD_0')).toBe('log')
+    const macd = chart.getPaneRenderers().find((r) => r.getPane().id === 'MACD_0')?.getPane()
+    expect(macd?.yAxis.getScaleType()).toBe('log')
+    await chart.destroy()
+  })
+
+  it('enter timeshare writes percent scaleTypes to kernel', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    chart.resize()
+    chart.updateSettings({ rightAxisType: 'log' })
+    const tsMode = (chart as unknown as { _timeShareMode: import('../modes/types').ChartModeHandler })
+      ._timeShareMode
+    chart.setActiveMode(tsMode)
+    expect(chart.kernel.pane.readonly.paneScaleTypes.peek().get('main')).toBe('percent')
+    expect(chart.getPaneRenderers()[0]?.getPane().yAxis.getScaleType()).toBe('percent')
+    await chart.destroy()
+  })
+
+  it('setActiveMode updates kernel chartMode', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    expect(chart.kernel.mode.readonly.chartMode.peek()).toBe('kline')
+    const tsMode = (chart as unknown as { _timeShareMode: import('../modes/types').ChartModeHandler })
+      ._timeShareMode
+    const kMode = (chart as unknown as { _kLineMode: import('../modes/types').ChartModeHandler })
+      ._kLineMode
+    chart.setActiveMode(tsMode)
+    expect(chart.kernel.mode.readonly.chartMode.peek()).toBe('timeshare')
+    chart.setActiveMode(kMode)
+    expect(chart.kernel.mode.readonly.chartMode.peek()).toBe('kline')
+    await chart.destroy()
+  })
+
+  it('setDrawingTool writes DrawingToolId to kernel', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    expect(chart.kernel.drawing.readonly.drawingTool.peek()).toBe('cursor')
+    chart.setDrawingTool('trend-line')
+    expect(chart.kernel.drawing.readonly.drawingTool.peek()).toBe('trend-line')
+    chart.setDrawingTool(null)
+    expect(chart.kernel.drawing.readonly.drawingTool.peek()).toBe('cursor')
+    await chart.destroy()
+  })
+
+  it('updateSettings writes kernel settings SSOT for renderer reads', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    chart.updateSettings({ showGridLines: false, rightAxisType: 'log' })
+    expect(chart.kernel.settings.readonly.settings.peek().showGridLines).toBe(false)
+    expect(chart.kernel.settings.readonly.settings.peek().rightAxisType).toBe('log')
+    expect(chart['renderer'].getSettings().showGridLines).toBe(false)
+    expect(chart['renderer'].getSettings().rightAxisType).toBe('log')
+    await chart.destroy()
+  })
+
+  it('updateSettings partial patch preserves prior keys', async () => {
+    const chart = new Chart(createDom(1000, 600), defaultOptions)
+    chart.updateSettings({ showGridLines: false })
+    chart.updateSettings({ rightAxisType: 'log' })
+    expect(chart.kernel.settings.readonly.settings.peek().showGridLines).toBe(false)
+    expect(chart.kernel.settings.readonly.settings.peek().rightAxisType).toBe('log')
+    await chart.destroy()
+  })
+
   it('normalizes only visible panes in updatePaneLayout', async () => {
     const chart = new Chart(createDom(1000, 800), defaultOptions)
     chart.updatePaneLayout([

package/src/engine/__tests__/subPaneManager.test.ts

@@ -1,20 +1,20 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 import type { IndicatorScheduler } from '../indicators/scheduler'
-import type { SubIndicatorType } from '../renderers/Indicator'
+import type { SubPaneSpec } from '../state/subPaneState'
 import { SubPaneManager, type SubPaneContext } from '../subPaneManager'
 
 function createMockScheduler(): Partial<IndicatorScheduler> {
   return {
-    getIndicatorMetadata: vi.fn((_id: string) => ({
-      name: _id,
+    getIndicatorMetadata: vi.fn((id: string) => ({
+      name: id,
       displayName: 'Test',
       category: 'sub' as const,
-      stateKey: _id,
+      stateKey: id,
       defaultPaneId: 'sub',
-      rendererFactory: vi.fn(() => ({
-        name: 'custom_rsi_rsi_0',
-        paneId: 'sub',
+      rendererFactory: vi.fn(({ paneId }: { paneId: string }) => ({
+        name: `${id.toLowerCase()}_${paneId}`,
+        paneId,
         priority: 0,
         draw: vi.fn(),
       })),
@@ -25,154 +25,151 @@ function createMockScheduler(): Partial<IndicatorScheduler> {
   }
 }
 
-function createMockContext(): SubPaneContext {
+function createMockContext(): SubPaneContext & {
+  renderers: Map<string, unknown>
+  layers: Set<string>
+} {
   const scheduler = createMockScheduler()
+  const renderers = new Map<string, unknown>()
+  const layers = new Set<string>()
   return {
-    getIndicatorScheduler: vi.fn(() => scheduler as unknown as IndicatorScheduler),
-    hasPane: vi.fn(() => false),
-    upsertPane: vi.fn(),
-    getRenderer: vi.fn(),
-    useRenderer: vi.fn(),
-    removeRenderer: vi.fn(),
+    renderers,
+    layers,
+    getIndicatorScheduler: () => scheduler as IndicatorScheduler,
+    getRenderer: vi.fn((name) => renderers.get(name) as any),
+    useRenderer: vi.fn((renderer: any) => renderers.set(renderer.name, renderer)),
+    removeRenderer: vi.fn((name) => renderers.delete(name)),
     setRendererEnabled: vi.fn(),
-    removePaneDefinition: vi.fn(),
     updateRendererConfig: vi.fn(),
-    getRightAxisWidth: vi.fn(() => 60),
-    getPriceLabelWidth: vi.fn(() => 60),
-    getYPaddingPx: vi.fn(() => 4),
-    getCrosshairPos: vi.fn(() => null),
-    getCrosshairPrice: vi.fn(() => null),
-    getActivePaneId: vi.fn(() => null),
-    addLayer: vi.fn(),
-    removeLayer: vi.fn(() => true),
-    getLayer: vi.fn(() => null),
+    getRightAxisWidth: () => 60,
+    getPriceLabelWidth: () => 60,
+    getYPaddingPx: () => 4,
+    getCrosshairPos: () => null,
+    getCrosshairPrice: () => null,
+    getActivePaneId: () => null,
+    addLayer: vi.fn((layer) => layers.add(layer.id)),
+    removeLayer: vi.fn((id) => layers.delete(id)),
+    getLayer: vi.fn((id) => (layers.has(id) ? ({ id } as any) : null)),
     setLayerVisibility: vi.fn(),
-    getRenderContext: vi.fn(() => null),
+    getRenderContext: () => null,
   }
 }
 
-describe('SubPaneManager', () => {
+describe('SubPaneManager runtime projection', () => {
   let manager: SubPaneManager
-  let ctx: SubPaneContext
+  let ctx: ReturnType<typeof createMockContext>
+  const rsi: SubPaneSpec = {
+    paneId: 'RSI_0',
+    indicatorId: 'RSI',
+    params: { period1: 6 },
+  }
 
   beforeEach(() => {
     manager = new SubPaneManager()
     ctx = createMockContext()
-    vi.clearAllMocks()
   })
 
-  describe('updateParams', () => {
-    it('should update paneTitle renderer config with new params and indicatorId', () => {
-      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
-        period1: 6,
-        period2: 12,
-        period3: 24,
-      })
-
-      const entry = manager.getByPaneId('RSI_0')
-      expect(entry).toBeDefined()
-      vi.clearAllMocks()
-
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(ctx, 'RSI_0', newParams)
-
-      expect(ctx.updateRendererConfig).toHaveBeenCalledWith(entry!.paneTitleRendererName, {
-        params: newParams,
-        indicatorId: 'RSI',
-      })
-    })
+  it('does not expose or own a business entries signal', () => {
+    expect('entriesSignal' in manager).toBe(false)
+  })
+
+  it('mounts desired resources once across repeated reconcile calls', () => {
+    manager.reconcile(ctx, [rsi])
+    manager.reconcile(ctx, [rsi])
 
-    it('should update main indicator renderer config with new params', () => {
-      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
-        period1: 6,
-        period2: 12,
-        period3: 24,
-      })
+    expect(ctx.useRenderer).toHaveBeenCalledTimes(3)
+    expect(manager.getMountedResources('RSI_0')?.rendererName).toBe('rsi_RSI_0')
+  })
 
-      const entry = manager.getByPaneId('RSI_0')
-      expect(entry).toBeDefined()
-      vi.clearAllMocks()
+  it('updates configs without recreating resources when only params change', () => {
+    manager.reconcile(ctx, [rsi])
+    vi.clearAllMocks()
 
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(ctx, 'RSI_0', newParams)
+    manager.reconcile(ctx, [{ ...rsi, params: { period1: 12 } }])
 
-      expect(ctx.updateRendererConfig).toHaveBeenCalledWith(entry!.rendererName, newParams)
+    expect(ctx.useRenderer).not.toHaveBeenCalled()
+    expect(ctx.updateRendererConfig).toHaveBeenCalledWith('rsi_RSI_0', { period1: 12 })
+    expect(ctx.updateRendererConfig).toHaveBeenCalledWith('paneTitle_RSI_0', {
+      params: { period1: 12 },
+      indicatorId: 'RSI',
     })
+  })
 
-    it('should update scheduler config via definition.updateConfig', () => {
-      const updateConfigSpy = vi.fn()
-      const customScheduler: Partial<IndicatorScheduler> = {
-        getIndicatorMetadata: vi.fn((_id: string) => ({
-          name: _id,
-          displayName: 'Test',
-          category: 'sub' as const,
-          stateKey: _id,
-          defaultPaneId: 'sub',
-          rendererFactory: vi.fn(() => ({
-            name: 'custom_rsi_rsi_0',
-            paneId: 'sub',
-            priority: 0,
-            draw: vi.fn(),
-          })),
-          updateConfig: updateConfigSpy,
-          scale: { indicatorKey: 'test', label: 'Test', decimals: 2 },
-        })),
-        onSubPaneChanged: vi.fn(),
-      }
-      const customCtx: SubPaneContext = {
-        ...ctx,
-        getIndicatorScheduler: vi.fn(() => customScheduler as unknown as IndicatorScheduler),
-      }
+  it('unmounts resources absent from desired state', () => {
+    manager.reconcile(ctx, [rsi])
+    vi.clearAllMocks()
 
-      manager.create(customCtx, 'RSI_0', 'RSI' as SubIndicatorType, {
-        period1: 6,
-        period2: 12,
-        period3: 24,
-      })
+    manager.reconcile(ctx, [])
 
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(customCtx, 'RSI_0', newParams)
+    expect(ctx.removeRenderer).toHaveBeenCalledTimes(3)
+    expect(manager.getMountedResources('RSI_0')).toBeUndefined()
+  })
 
-      expect(updateConfigSpy).toHaveBeenCalled()
+  it('does not record a mount when renderer registration throws', () => {
+    ctx.useRenderer = vi.fn(() => {
+      throw new Error('mount failed')
     })
 
-    it('should update entry params in the manager', () => {
-      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
-        period1: 6,
-        period2: 12,
-        period3: 24,
-      })
+    expect(() => manager.reconcile(ctx, [rsi])).not.toThrow()
+    expect(manager.getMountedResources('RSI_0')).toBeUndefined()
+  })
+
+  it('does not record a mount when scheduler configuration throws', () => {
+    const scheduler = ctx.getIndicatorScheduler()
+    vi.mocked(scheduler.getIndicatorMetadata).mockReturnValue({
+      ...scheduler.getIndicatorMetadata('RSI')!,
+      updateConfig: vi.fn(() => {
+        throw new Error('config failed')
+      }),
+    })
 
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(ctx, 'RSI_0', newParams)
+    expect(() => manager.reconcile(ctx, [rsi])).not.toThrow()
+    expect(manager.getMountedResources('RSI_0')).toBeUndefined()
+  })
 
-      const entry = manager.getByPaneId('RSI_0')
-      expect(entry?.params).toEqual(newParams)
+  it('keeps a failed parameter projection retryable', () => {
+    manager.reconcile(ctx, [rsi])
+    ctx.updateRendererConfig = vi.fn().mockImplementationOnce(() => {
+      throw new Error('config failed')
     })
 
-    it('should fire entries signal on update', () => {
-      manager.create(ctx, 'RSI_0', 'RSI' as SubIndicatorType, {
-        period1: 6,
-        period2: 12,
-        period3: 24,
-      })
+    expect(() => manager.reconcile(ctx, [{ ...rsi, params: { period1: 12 } }])).not.toThrow()
+    manager.reconcile(ctx, [{ ...rsi, params: { period1: 12 } }])
+
+    expect(ctx.useRenderer).toHaveBeenCalledTimes(6)
+    expect(manager.getMountedResources('RSI_0')).toBeDefined()
+  })
+
+  it('distinguishes non-finite and null parameter values in projection keys', () => {
+    manager.reconcile(ctx, [{ ...rsi, params: { threshold: Number.NaN } }])
+    vi.clearAllMocks()
 
-      const listener = vi.fn()
-      manager.entriesSignal.subscribe(listener)
-      vi.clearAllMocks()
+    manager.reconcile(ctx, [{ ...rsi, params: { threshold: null } }])
 
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(ctx, 'RSI_0', newParams)
+    expect(ctx.updateRendererConfig).toHaveBeenCalledWith('rsi_RSI_0', {
+      threshold: null,
+    })
+  })
 
-      expect(listener).toHaveBeenCalledTimes(1)
+  it('removes the old projection when the replacement factory throws', () => {
+    manager.reconcile(ctx, [rsi])
+    const scheduler = ctx.getIndicatorScheduler()
+    vi.mocked(scheduler.getIndicatorMetadata).mockImplementation((id: string) => {
+      const definition = createMockScheduler().getIndicatorMetadata?.(id)
+      if (id === 'MACD' && definition) {
+        return {
+          ...definition,
+          rendererFactory: () => {
+            throw new Error('factory failed')
+          },
+        }
+      }
+      return definition
     })
 
-    it('should silently skip when paneId does not exist', () => {
-      const newParams = { period1: 10, period2: 20, period3: 30 }
-      manager.updateParams(ctx, 'NONEXISTENT', newParams)
+    manager.reconcile(ctx, [{ paneId: 'RSI_0', indicatorId: 'MACD', params: {} }])
 
-      expect(ctx.updateRendererConfig).not.toHaveBeenCalled()
-      expect(ctx.getIndicatorScheduler().onSubPaneChanged).not.toHaveBeenCalled()
-    })
+    expect(manager.getMountedResources('RSI_0')).toBeUndefined()
+    expect(ctx.removeRenderer).toHaveBeenCalled()
   })
 })