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

package/src/engine/state/__tests__/markerState.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import type { CustomMarkerEntity } from '../../marker/registry'
+import { createMarkerState } from '../markerState'
+
+function mk(id: string, overrides: Partial<CustomMarkerEntity> = {}): CustomMarkerEntity {
+  return {
+    id,
+    date: '2025-01-15',
+    timestamp: Date.UTC(2025, 0, 15, -8, 0, 0, 0),
+    shape: 'circle',
+    ...overrides,
+  }
+}
+
+describe('markerState', () => {
+  it('publishes immutable custom marker snapshots', () => {
+    const state = createMarkerState()
+    const style = { size: 12, fillColor: '#f00' }
+    state.actions.setCustomMarkers([mk('a', { style })])
+    style.size = 99
+
+    const stored = state.readonly.customMarkers.peek().get('a')!
+    expect(stored.style).toEqual({ size: 12, fillColor: '#f00' })
+    expect(Object.isFrozen(stored)).toBe(true)
+    expect(Object.isFrozen(stored.style)).toBe(true)
+    expect(() => {
+      ;(stored as { id: string }).id = 'hack'
+    }).toThrow()
+  })
+
+  it('does not notify when setCustomMarkers is deeply equal', () => {
+    const state = createMarkerState()
+    const listener = vi.fn()
+    state.readonly.customMarkers.subscribe(listener)
+
+    state.actions.setCustomMarkers([mk('a')])
+    state.actions.setCustomMarkers([mk('a')])
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+
+  it('registerCustomMarker upserts by id', () => {
+    const state = createMarkerState()
+    state.actions.setCustomMarkers([mk('a', { shape: 'circle' })])
+    state.actions.registerCustomMarker(mk('a', { shape: 'flag' }))
+    state.actions.registerCustomMarker(mk('b', { shape: 'diamond' }))
+
+    const map = state.readonly.customMarkers.peek()
+    expect(map.size).toBe(2)
+    expect(map.get('a')!.shape).toBe('flag')
+    expect(map.get('b')!.shape).toBe('diamond')
+  })
+
+  it('clearCustomMarkers empties the map', () => {
+    const state = createMarkerState()
+    state.actions.setCustomMarkers([mk('a'), mk('b')])
+    state.actions.clearCustomMarkers()
+    expect(state.readonly.customMarkers.peek().size).toBe(0)
+  })
+
+  it('rejects non JSON-like metadata', () => {
+    const state = createMarkerState()
+    expect(() =>
+      state.actions.setCustomMarkers([mk('a', { metadata: { d: new Date() } })]),
+    ).toThrow(TypeError)
+    expect(state.readonly.customMarkers.peek().size).toBe(0)
+  })
+
+  it('dispose resets to empty', () => {
+    const state = createMarkerState()
+    state.actions.setCustomMarkers([mk('a')])
+    state.dispose()
+    expect(state.readonly.customMarkers.peek().size).toBe(0)
+  })
+})

package/src/engine/state/__tests__/modeState.test.ts

@@ -0,0 +1,20 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { createModeState } from '../modeState'
+
+describe('modeState', () => {
+  it('defaults to kline', () => {
+    const m = createModeState()
+    expect(m.readonly.chartMode.peek()).toBe('kline')
+  })
+
+  it('setChartMode updates and equal-skips', () => {
+    const m = createModeState()
+    const listener = vi.fn()
+    m.readonly.chartMode.subscribe(listener)
+    m.actions.setChartMode('timeshare')
+    expect(m.readonly.chartMode.peek()).toBe('timeshare')
+    m.actions.setChartMode('timeshare')
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+})

package/src/engine/state/__tests__/paneState.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest'
+import { createPaneState } from '../paneState'
+
+describe('paneState', () => {
+  it('commitLayout publishes ratios and specs atomically', () => {
+    const m = createPaneState()
+    const snaps: Array<{ ratios: number; specs: number }> = []
+    m.readonly.paneRatios.subscribe(() => {
+      snaps.push({
+        ratios: Object.keys(m.readonly.paneRatios.peek()).length,
+        specs: m.readonly.paneSpecs.peek().length,
+      })
+    })
+    m.readonly.paneSpecs.subscribe(() => {
+      snaps.push({
+        ratios: Object.keys(m.readonly.paneRatios.peek()).length,
+        specs: m.readonly.paneSpecs.peek().length,
+      })
+    })
+
+    m.actions.commitLayout({ main: 1 }, [{ id: 'main', ratio: 1, role: 'price' }])
+
+    expect(m.readonly.paneRatios()).toEqual({ main: 1 })
+    expect(m.readonly.paneSpecs()).toEqual([{ id: 'main', ratio: 1, role: 'price' }])
+    for (const s of snaps) {
+      expect(s).toEqual({ ratios: 1, specs: 1 })
+    }
+  })
+
+  it('commitLayout copies ratios and specs', () => {
+    const m = createPaneState()
+    const ratios = { main: 1 }
+    const specs = [{ id: 'main', ratio: 1, role: 'price' as const }]
+    m.actions.commitLayout(ratios, specs)
+    ratios.main = 0.5
+    specs[0]!.ratio = 0.5
+    expect(m.readonly.paneRatios().main).toBe(1)
+    expect(m.readonly.paneSpecs()[0]?.ratio).toBe(1)
+  })
+
+  it('commitLayout does not invent scale types for new panes', () => {
+    const m = createPaneState()
+    m.actions.commitLayout({ main: 1 }, [{ id: 'main', ratio: 1, role: 'price' }])
+    expect(m.readonly.paneScaleTypes.peek().has('main')).toBe(false)
+  })
+
+  it('setPaneScaleType / replacePaneScaleTypes / removePaneScaleType', () => {
+    const m = createPaneState()
+    m.actions.commitLayout({ main: 1, MACD: 1 }, [
+      { id: 'main', ratio: 1, role: 'price' },
+      { id: 'MACD', ratio: 1, role: 'indicator' },
+    ])
+    m.actions.setPaneScaleType('main', 'log')
+    expect(m.readonly.paneScaleTypes.peek().get('main')).toBe('log')
+    m.actions.replacePaneScaleTypes(new Map([['main', 'percent']]))
+    expect(m.readonly.paneScaleTypes.peek().get('main')).toBe('percent')
+    expect(m.readonly.paneScaleTypes.peek().has('MACD')).toBe(false)
+    m.actions.removePaneScaleType('main')
+    expect(m.readonly.paneScaleTypes.peek().has('main')).toBe(false)
+  })
+
+  it('commitLayout preserves existing scale types for surviving panes only', () => {
+    const m = createPaneState()
+    m.actions.commitLayout({ main: 1 }, [{ id: 'main', ratio: 1, role: 'price' }])
+    m.actions.setPaneScaleType('main', 'log')
+    m.actions.commitLayout({ main: 0.75, RSI: 0.25 }, [
+      { id: 'main', ratio: 0.75, role: 'price' },
+      { id: 'RSI', ratio: 0.25, role: 'indicator' },
+    ])
+    expect(m.readonly.paneScaleTypes.peek().get('main')).toBe('log')
+    expect(m.readonly.paneScaleTypes.peek().has('RSI')).toBe(false)
+  })
+})

package/src/engine/state/__tests__/settingsState.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { resolveSettings, type ChartSettings } from '../../../foundation/config/chartSettings'
+import { createSettingsState } from '../settingsState'
+
+describe('settingsState', () => {
+  it('starts as fully resolved defaults', () => {
+    const s = createSettingsState()
+    const resolved = resolveSettings({})
+    expect(s.readonly.settings.peek().showGridLines).toBe(resolved.showGridLines)
+    expect(s.readonly.settings.peek().rightAxisType).toBe(resolved.rightAxisType)
+  })
+
+  it('replace merges partial via resolveSettings', () => {
+    const s = createSettingsState()
+    s.actions.replace({ showGridLines: false })
+    expect(s.readonly.settings.peek().showGridLines).toBe(false)
+    expect(s.readonly.settings.peek().enableWebGLRendering).toBeDefined()
+  })
+
+  it('patch merges onto current then re-resolves', () => {
+    const s = createSettingsState()
+    s.actions.replace({ showGridLines: false })
+    s.actions.patch({ rightAxisType: 'log' })
+    expect(s.readonly.settings.peek().showGridLines).toBe(false)
+    expect(s.readonly.settings.peek().rightAxisType).toBe('log')
+  })
+
+  it('equal-skip does not notify on identical replace', () => {
+    const s = createSettingsState()
+    s.actions.replace({ showGridLines: true })
+    const listener = vi.fn()
+    s.readonly.settings.subscribe(listener)
+    s.actions.replace({ showGridLines: true })
+    expect(listener).not.toHaveBeenCalled()
+  })
+
+  it('snapshot is frozen', () => {
+    const s = createSettingsState()
+    const snap = s.readonly.settings.peek() as ChartSettings
+    expect(Object.isFrozen(snap)).toBe(true)
+    expect(() => {
+      ;(snap as { showGridLines?: boolean }).showGridLines = false
+    }).toThrow()
+  })
+})

package/src/engine/state/__tests__/subPaneState.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { ChartStateKernel } from '../chartStateKernel'
+import { createSubPaneState } from '../subPaneState'
+
+describe('subPaneState', () => {
+  it('publishes immutable entry snapshots and copies action inputs', () => {
+    const state = createSubPaneState()
+    const params = { period1: 6 }
+
+    state.actions.upsert({ paneId: 'RSI_0', indicatorId: 'RSI', params })
+    params.period1 = 99
+
+    const entry = state.readonly.entries.peek()[0]!
+    expect(entry.params).toEqual({ period1: 6 })
+    expect(Object.isFrozen(entry)).toBe(true)
+    expect(Object.isFrozen(entry.params)).toBe(true)
+    expect(() => {
+      ;(entry.params as Record<string, unknown>).period1 = 12
+    }).toThrow()
+  })
+
+  it('does not publish a new snapshot for an identical upsert', () => {
+    const state = createSubPaneState()
+    const listener = vi.fn()
+    state.readonly.entries.subscribe(listener)
+
+    state.actions.upsert({ paneId: 'RSI_0', indicatorId: 'RSI', params: { period1: 6 } })
+    state.actions.upsert({ paneId: 'RSI_0', indicatorId: 'RSI', params: { period1: 6 } })
+
+    expect(listener).toHaveBeenCalledTimes(1)
+  })
+
+  it('deeply snapshots nested parameter arrays and objects', () => {
+    const state = createSubPaneState()
+    const params = { levels: [20, 80], style: { width: 2 } }
+
+    state.actions.upsert({ paneId: 'RSI_0', indicatorId: 'RSI', params })
+    params.levels[0] = 10
+    params.style.width = 4
+
+    const stored = state.readonly.entries.peek()[0]!.params as typeof params
+    expect(stored).toEqual({ levels: [20, 80], style: { width: 2 } })
+    expect(Object.isFrozen(stored.levels)).toBe(true)
+    expect(Object.isFrozen(stored.style)).toBe(true)
+  })
+
+  it('rejects mutable non-plain parameter objects', () => {
+    const state = createSubPaneState()
+
+    expect(() =>
+      state.actions.upsert({
+        paneId: 'RSI_0',
+        indicatorId: 'RSI',
+        params: { dates: new Map([['start', new Date()]]) },
+      }),
+    ).toThrow(TypeError)
+    expect(state.readonly.entries.peek()).toEqual([])
+  })
+
+  it('rejects bigint and symbol parameter values', () => {
+    const state = createSubPaneState()
+
+    expect(() =>
+      state.actions.upsert({
+        paneId: 'RSI_0',
+        indicatorId: 'RSI',
+        params: { value: 1n },
+      }),
+    ).toThrow(TypeError)
+    expect(() =>
+      state.actions.upsert({
+        paneId: 'RSI_0',
+        indicatorId: 'RSI',
+        params: { value: Symbol('x') },
+      }),
+    ).toThrow(TypeError)
+  })
+
+  it('replace rewrites even when params are equal', () => {
+    const state = createSubPaneState()
+    state.actions.upsert({ paneId: 'RSI_0', indicatorId: 'RSI', params: { period1: 6 } })
+    const first = state.readonly.entries.peek()
+
+    state.actions.replace({ paneId: 'RSI_0', indicatorId: 'RSI', params: { period1: 6 } })
+
+    expect(state.readonly.entries.peek()).not.toBe(first)
+    expect(state.readonly.entries.peek()[0]).toEqual({
+      paneId: 'RSI_0',
+      indicatorId: 'RSI',
+      params: { period1: 6 },
+    })
+  })
+})
+
+describe('ChartStateKernel sub-pane transactions', () => {
+  function createKernel() {
+    return new ChartStateKernel({
+      initialOptions: {
+        minKWidth: 3,
+        maxKWidth: 20,
+        zoomLevelCount: 10,
+        bottomAxisHeight: 24,
+        rightAxisWidth: 60,
+        leftAxisWidth: 0,
+        yPaddingPx: 4,
+        panes: [{ id: 'main', ratio: 1, visible: true, role: 'price' }],
+      },
+      initialZoomLevel: 0,
+      scheduleDraw: () => {},
+    })
+  }
+
+  it('publishes pane layout and sub-pane entry as one complete snapshot', () => {
+    const kernel = createKernel()
+    const snapshots: Array<{ paneIds: string[]; entryIds: string[] }> = []
+    const capture = () => {
+      snapshots.push({
+        paneIds: kernel.pane.readonly.paneSpecs.peek().map((pane) => pane.id),
+        entryIds: kernel.subPane.readonly.entries.peek().map((entry) => entry.paneId),
+      })
+    }
+    kernel.pane.readonly.paneSpecs.subscribe(capture)
+    kernel.subPane.readonly.entries.subscribe(capture)
+
+    kernel.actions.createSubPane('RSI_0', 'RSI', { period1: 6 })
+
+    expect(snapshots.length).toBeGreaterThan(0)
+    expect(snapshots).toEqual(
+      snapshots.map(() => ({ paneIds: ['main', 'RSI_0'], entryIds: ['RSI_0'] })),
+    )
+    expect(kernel.pane.readonly.paneRatios.peek()).toEqual({ main: 0.75, RSI_0: 0.25 })
+  })
+
+  it('removes pane layout and sub-pane entry atomically', () => {
+    const kernel = createKernel()
+    kernel.actions.createSubPane('RSI_0', 'RSI', { period1: 6 })
+    const snapshots: Array<{ paneIds: string[]; entryIds: string[] }> = []
+    const capture = () => {
+      snapshots.push({
+        paneIds: kernel.pane.readonly.paneSpecs.peek().map((pane) => pane.id),
+        entryIds: kernel.subPane.readonly.entries.peek().map((entry) => entry.paneId),
+      })
+    }
+    kernel.pane.readonly.paneSpecs.subscribe(capture)
+    kernel.subPane.readonly.entries.subscribe(capture)
+
+    kernel.actions.removeSubPane('RSI_0')
+
+    expect(snapshots).toEqual(snapshots.map(() => ({ paneIds: ['main'], entryIds: [] })))
+  })
+})

package/src/engine/state/__tests__/zoomState.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import { createSignal } from '../../../foundation/reactivity/signal'
+import { createZoomState } from '../zoomState'
+
+function createState() {
+  const minKWidth$ = createSignal(4)
+  const maxKWidth$ = createSignal(20)
+  return createZoomState({ minKWidth$, maxKWidth$, zoomLevelCount: 5 })
+}
+
+describe('zoomState', () => {
+  it('clamps zoom levels at the state boundary', () => {
+    const state = createState()
+
+    state.actions.setZoomLevel(99)
+    expect(state.readonly.zoomLevel()).toBe(5)
+
+    state.actions.setZoomLevel(-1)
+    expect(state.readonly.zoomLevel()).toBe(1)
+  })
+
+  it('uses an explicit kWidth until a discrete zoom level is selected', () => {
+    const state = createState()
+
+    state.actions.setDirectKWidth(7.25)
+    expect(state.readonly.kWidth()).toBe(7.25)
+
+    state.actions.setZoomLevel(3)
+    expect(state.readonly.kWidth()).toBe(12)
+  })
+})