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

package/src/engine/controller/markerInteraction.ts

@@ -1,13 +1,7 @@
 import type { MarkerEntity, CustomMarkerEntity, MarkerManager } from '../marker/registry'
 
-/** Marker交互状态，管理标记 hover/click 状态和回调，与 InteractionController 正交。 */
+/** Marker交互状态 v2 — 精简为仅含回调注册与 hitTest 逻辑。状态层面已合并入 interactionState。 */
 export class MarkerInteractionState {
-  hoveredMarkerId: string | null = null
-  clickedMarkerId: string | null = null
-  hoveredMarkerData: MarkerEntity | null = null
-  clickedMarkerData: MarkerEntity | null = null
-  hoveredCustomMarker: CustomMarkerEntity | null = null
-
   private onMarkerHoverCallback?: (marker: MarkerEntity | null) => void
   private onMarkerClickCallback?: (marker: MarkerEntity) => void
   private onCustomMarkerHoverCallback?: (marker: CustomMarkerEntity | null) => void
@@ -29,9 +23,15 @@ export class MarkerInteractionState {
     this.onCustomMarkerClickCallback = callback
   }
 
+  get onMarkerHover(): ((marker: MarkerEntity | null) => void) | undefined {
+    return this.onMarkerHoverCallback
+  }
+
+  get onCustomMarkerHover(): ((marker: CustomMarkerEntity | null) => void) | undefined {
+    return this.onCustomMarkerHoverCallback
+  }
+
   handleClick(hitMarker: MarkerEntity): void {
-    this.clickedMarkerId = hitMarker.id
-    this.clickedMarkerData = hitMarker
     this.onMarkerClickCallback?.(hitMarker)
   }
 
@@ -41,93 +41,33 @@ export class MarkerInteractionState {
     mouseX: number,
     mouseY: number,
     markerManager: MarkerManager,
-  ): boolean {
+  ): { hit: boolean; hitMarkerId: string | null; hitMarkerData: MarkerEntity | null; hitCustomMarker: CustomMarkerEntity | null } {
     const hitMarker = markerManager.hitTest(worldX, mouseY, 3)
     if (hitMarker) {
-      return this.enterMarkerHover(hitMarker, markerManager)
+      this.onMarkerHoverCallback?.(hitMarker)
+      return { hit: true, hitMarkerId: hitMarker.id, hitMarkerData: hitMarker, hitCustomMarker: null }
     }
-    this.leaveMarkerHover(markerManager)
 
     const hitCustomMarker = markerManager.hitTestCustomMarker(mouseX, mouseY)
     if (hitCustomMarker) {
-      return this.enterCustomMarkerHover(hitCustomMarker, markerManager)
-    }
-    this.leaveCustomMarkerHover()
-
-    return false
-  }
-
-  private enterMarkerHover(hitMarker: MarkerEntity, markerManager: MarkerManager): true {
-    if (this.hoveredMarkerId !== hitMarker.id) {
-      this.hoveredMarkerId = hitMarker.id
-      this.hoveredMarkerData = hitMarker
-      markerManager.setHover(hitMarker.id)
-      this.onMarkerHoverCallback?.(hitMarker)
-    }
-    if (this.hoveredCustomMarker !== null) {
-      this.hoveredCustomMarker = null
-      this.onCustomMarkerHoverCallback?.(null)
-    }
-    return true
-  }
-
-  private leaveMarkerHover(markerManager: MarkerManager): void {
-    if (this.hoveredMarkerId !== null) {
-      this.hoveredMarkerId = null
-      this.hoveredMarkerData = null
-      markerManager.setHover(null)
-      this.onMarkerHoverCallback?.(null)
-    } else {
-      this.hoveredMarkerData = null
-    }
-  }
-
-  private enterCustomMarkerHover(
-    hitCustomMarker: CustomMarkerEntity,
-    markerManager: MarkerManager,
-  ): true {
-    if (this.hoveredCustomMarker?.id !== hitCustomMarker.id) {
-      this.hoveredCustomMarker = hitCustomMarker
       this.onCustomMarkerHoverCallback?.(hitCustomMarker)
+      return { hit: true, hitMarkerId: null, hitMarkerData: null, hitCustomMarker }
     }
-    if (this.hoveredMarkerId !== null) {
-      this.hoveredMarkerId = null
-      this.hoveredMarkerData = null
-      markerManager.setHover(null)
-      this.onMarkerHoverCallback?.(null)
-    }
-    return true
-  }
 
-  private leaveCustomMarkerHover(): void {
-    if (this.hoveredCustomMarker !== null) {
-      this.hoveredCustomMarker = null
-      this.onCustomMarkerHoverCallback?.(null)
-    }
+    this.onMarkerHoverCallback?.(null)
+    this.onCustomMarkerHoverCallback?.(null)
+    return { hit: false, hitMarkerId: null, hitMarkerData: null, hitCustomMarker: null }
   }
 
   /** 清空 hover 状态并触发回调（拖拽/离开时调用）。需要 markerManager 以便同步清除 Native hover。 */
   clearAll(markerManager: MarkerManager): void {
-    if (this.hoveredMarkerId !== null) {
-      this.hoveredMarkerId = null
-      this.hoveredMarkerData = null
-      markerManager.setHover(null)
-      this.onMarkerHoverCallback?.(null)
-    } else {
-      this.hoveredMarkerData = null
-    }
-    if (this.hoveredCustomMarker !== null) {
-      this.hoveredCustomMarker = null
-      this.onCustomMarkerHoverCallback?.(null)
-    }
+    markerManager.setHover(null)
+    this.onMarkerHoverCallback?.(null)
+    this.onCustomMarkerHoverCallback?.(null)
   }
 
   /** 全量重置（数据更新时调用，不触发热点回调） */
   reset(): void {
-    this.hoveredMarkerId = null
-    this.clickedMarkerId = null
-    this.hoveredMarkerData = null
-    this.clickedMarkerData = null
-    this.hoveredCustomMarker = null
+    // No state to reset — state lives in interactionState
   }
 }

package/src/engine/controller/tooltipPosition.ts

@@ -1,3 +1,7 @@
+import { isOnRightHalf } from '../../foundation/utils/viewportSide'
+
+export type TooltipPositionMode = 'crosshair' | 'adaptive'
+
 export interface TooltipPositionInput {
   mouseX: number
   mouseY: number
@@ -7,6 +11,8 @@ export interface TooltipPositionInput {
   plotHeight: number
   tooltipSize: { width: number; height: number }
   useAnchorPositioning: boolean
+  mode: TooltipPositionMode
+  adaptiveCorner?: 'top-left' | 'top-right'
 }
 
 export interface TooltipPositionOutput {
@@ -14,8 +20,23 @@ export interface TooltipPositionOutput {
   anchorPlacement?: 'right-bottom' | 'left-bottom'
 }
 
+const PADDING = 12
+
 export function computeTooltipPosition(input: TooltipPositionInput): TooltipPositionOutput {
-  const padding = 12
+  if (input.mode === 'adaptive') {
+    const tooltipW = input.tooltipSize.width
+    const onRight = input.adaptiveCorner
+      ? input.adaptiveCorner === 'top-left'
+      : isOnRightHalf(input.mouseX, input.viewWidth)
+    return {
+      pos: {
+        x: onRight ? PADDING : Math.max(PADDING, input.viewWidth - tooltipW - PADDING),
+        y: PADDING,
+      },
+    }
+  }
+
+  const padding = PADDING
   const preferGap = 14
 
   if (input.useAnchorPositioning) {

package/src/engine/data/__tests__/chartDataManager.incrementalLoad.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { JSDOM } from 'jsdom'
+
+import type { DataFetcher, KLineData, SymbolSpec } from '../../../controllers/types'
+import { computed, createSignal } from '../../../foundation/reactivity/signal'
+import type { ChartDom } from '../../chartTypes'
+import { createDataManagerState } from '../../state/dataManagerState'
+import { createDataState } from '../../state/dataState'
+import { ChartDataManager, type DataDependencies } from '../chartDataManager'
+
+const MS_PER_DAY = 86_400_000
+
+function makeKLine(timestamp: number): KLineData {
+  return {
+    timestamp,
+    open: 100,
+    high: 110,
+    low: 90,
+    close: 105,
+    volume: 1_000,
+  }
+}
+
+function createDependencies(
+  dom: ChartDom,
+  setSymbols: (symbols: ReadonlyArray<SymbolSpec>) => void,
+  symbols$: ReturnType<typeof createSignal<ReadonlyArray<SymbolSpec>>>,
+): DataDependencies {
+  let scrollLeft = 800
+  return {
+    getOption: () => ({ kWidth: 8, kGap: 2 }),
+    getEffectiveDpr: () => 1,
+    getLogicalScrollLeft: () => scrollLeft,
+    getCachedScrollLeft: () => scrollLeft,
+    setScrollLeft: (value) => {
+      scrollLeft = value
+    },
+    getDom: () => dom,
+    getObservedSize: () => ({ width: 800, height: 600 }),
+    getViewport: () => null,
+    getVisibleRange: () => null,
+    getLeftLoadBufferWidth: () => 800,
+    getContentWidth: () => 1600,
+    scheduleDraw: () => {},
+    resetInteraction: () => {},
+    getIndicatorScheduler: () => ({
+      update: () => true,
+      busySignal: createSignal(false),
+    }),
+    isPointerDown: () => false,
+    onTimeShareDataReady: () => {},
+    setSymbols,
+    setComparisonLoading: () => {},
+    comparisonSpecs$: computed(() => symbols$().slice(1)),
+    comparisonColors$: createSignal(new Map() as ReadonlyMap<string, string>),
+    comparisonLoading$: createSignal(false),
+  }
+}
+
+describe('ChartDataManager incremental load', () => {
+  let manager: ChartDataManager | null = null
+  let document: Document
+
+  beforeEach(() => {
+    const dom = new JSDOM('<div id="container"><div id="scroll-content"></div></div>')
+    document = dom.window.document
+    vi.stubGlobal('window', dom.window)
+  })
+
+  afterEach(() => {
+    manager?.destroy()
+    manager = null
+    vi.unstubAllGlobals()
+  })
+
+  it('flushes the first prepend hint when loading becomes idle', async () => {
+    const now = Date.now()
+    const initialStart = now - 365 * MS_PER_DAY
+    let fetchCount = 0
+    const fetcher: DataFetcher = async () => {
+      fetchCount++
+      return fetchCount === 1
+        ? [makeKLine(initialStart), makeKLine(now)]
+        : [makeKLine(initialStart - 90 * MS_PER_DAY)]
+    }
+    const spec: SymbolSpec = {
+      symbol: 'sh.600000',
+      period: 'daily',
+      adjust: 'none',
+      source: 'mock',
+    }
+    const dataState = createDataState()
+    const symbols$ = createSignal<ReadonlyArray<SymbolSpec>>([])
+    const dataManagerState = createDataManagerState()
+    const container = document.querySelector<HTMLDivElement>('#container')!
+    const scrollContent = document.querySelector<HTMLDivElement>('#scroll-content')!
+    manager = new ChartDataManager(
+      createDependencies(
+        { container, scrollContent },
+        (symbols) => {
+          symbols$.set(symbols)
+          dataState.actions.setSymbols(symbols)
+        },
+        symbols$,
+      ),
+      dataState,
+      dataManagerState,
+    )
+    manager.setDataFetcher(fetcher)
+    manager.setSymbols([spec])
+
+    await vi.waitFor(() => expect(manager!.dataBuffer.loading.peek()).toBe(false))
+    expect(dataState.readonly.loading.peek()).toBe(false)
+
+    manager.dataBuffer.ensureRange(initialStart - 30 * MS_PER_DAY, initialStart)
+
+    await vi.waitFor(() => expect(manager!.dataBuffer.loading.peek()).toBe(false))
+    await vi.waitFor(() => {
+      expect(dataState.readonly.loading.peek()).toBe(false)
+      expect(dataManagerState.readonly.pendingIncrementalLoad.peek().count).toBe(0)
+    })
+    const hint = document.querySelector<HTMLDivElement>('.klc-incremental-load-hint')
+    expect(hint).not.toBeNull()
+    expect(hint!.style.opacity).toBe('1')
+    expect(hint!.style.left).toBe('800px')
+    expect(fetchCount).toBe(2)
+  })
+})

package/src/engine/data/__tests__/comparisonManager.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import type { SymbolSpec } from '../../../controllers/types'
+import { ComparisonManager } from '../comparisonManager'
+
+function createHarness() {
+  let specs: ReadonlyArray<SymbolSpec> = []
+  const buffers = new Map<
+    string,
+    {
+      loading: { peek: () => boolean; subscribe: (listener: () => void) => () => void }
+      data: { subscribe: (listener: () => void) => () => void }
+      setSymbol: ReturnType<typeof vi.fn>
+      setInlineData: ReturnType<typeof vi.fn>
+      getRawData: () => []
+    }
+  >()
+  const createComparisonBuffer = vi.fn((spec: SymbolSpec) => {
+    const key = `cmp:${spec.symbol}:${spec.period ?? 'daily'}`
+    const buffer = {
+      loading: { peek: () => false, subscribe: () => () => {} },
+      data: { subscribe: () => () => {} },
+      setSymbol: vi.fn(),
+      setInlineData: vi.fn(),
+      getRawData: () => [] as [],
+    }
+    buffers.set(key, buffer)
+    return { key, buffer: buffer as any }
+  })
+  const setLoading = vi.fn()
+  const manager = new ComparisonManager({
+    createComparisonBuffer,
+    disposeBuffer: (key) => {
+      buffers.delete(key)
+    },
+    getKLineBuffer: (key) => buffers.get(key) as any,
+    getKLineBufferKeys: () => [...buffers.keys()],
+    scheduleDraw: vi.fn(),
+    getSpecs: () => specs,
+    setLoading,
+  })
+  return {
+    manager,
+    buffers,
+    createComparisonBuffer,
+    setLoading,
+    setSpecs(next: ReadonlyArray<SymbolSpec>) {
+      specs = next
+    },
+  }
+}
+
+describe('ComparisonManager runtime projection', () => {
+  it('reads specs from the injected kernel reader without a local shadow', () => {
+    const harness = createHarness()
+    harness.setSpecs([{ symbol: 'A', period: 'daily' }])
+    expect(harness.manager.specs).toEqual([{ symbol: 'A', period: 'daily' }])
+
+    harness.setSpecs([{ symbol: 'B', period: 'weekly' }])
+    expect(harness.manager.specs).toEqual([{ symbol: 'B', period: 'weekly' }])
+  })
+
+  it('reconciles buffers idempotently from desired specs', () => {
+    const harness = createHarness()
+    harness.setSpecs([{ symbol: 'A', period: 'daily' }])
+
+    harness.manager.reconcile()
+    harness.manager.reconcile()
+
+    expect(harness.createComparisonBuffer).toHaveBeenCalledTimes(1)
+    expect([...harness.buffers.keys()]).toEqual(['cmp:A:daily'])
+  })
+
+  it('removes runtime buffers that are absent from desired specs', () => {
+    const harness = createHarness()
+    harness.setSpecs([
+      { symbol: 'A', period: 'daily' },
+      { symbol: 'B', period: 'daily' },
+    ])
+    harness.manager.reconcile()
+
+    harness.setSpecs([{ symbol: 'B', period: 'daily' }])
+    harness.manager.reconcile()
+
+    expect([...harness.buffers.keys()]).toEqual(['cmp:B:daily'])
+    expect(harness.manager.specs).toEqual([{ symbol: 'B', period: 'daily' }])
+  })
+
+  it('sets inline data only for a desired comparison', () => {
+    const harness = createHarness()
+    expect(harness.manager.setData('A', [])).toBe(false)
+
+    harness.setSpecs([{ symbol: 'A', period: 'daily' }])
+    harness.manager.reconcile()
+    expect(harness.manager.setData('A', [])).toBe(true)
+    expect(harness.buffers.get('cmp:A:daily')?.setInlineData).toHaveBeenCalledWith([])
+  })
+
+  it('clearAll only clears runtime resources and loading', () => {
+    const harness = createHarness()
+    harness.setSpecs([{ symbol: 'A', period: 'daily' }])
+    harness.manager.reconcile()
+
+    harness.manager.clearAll()
+
+    expect(harness.buffers.size).toBe(0)
+    expect(harness.manager.specs).toEqual([{ symbol: 'A', period: 'daily' }])
+    expect(harness.setLoading).toHaveBeenLastCalledWith(false)
+  })
+})

package/src/engine/data/__tests__/contentGeometry.parity.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it } from 'vitest'
+
+import { SCROLL_TRAILING_SLOTS } from '../scrollCompensator'
+import { getPhysicalKLineConfig } from '../../utils/klineConfig'
+import {
+  computeContentWidth,
+  computeLeftLoadBufferWidth,
+  computeMaxScrollLeft,
+  type ContentGeometryInput,
+} from '../../state/contentGeometry'
+
+const baseInput = (overrides: Partial<ContentGeometryInput> = {}): ContentGeometryInput => ({
+  viewWidth: 800,
+  plotWidth: 800,
+  dataLength: 100,
+  period: 'daily',
+  dpr: 1,
+  kWidth: 8,
+  kGap: 2,
+  ...overrides,
+})
+
+describe('contentGeometry parity', () => {
+  it('dataLength 0 → left buffer 0, content 0', () => {
+    const input = baseInput({ dataLength: 0 })
+    expect(computeLeftLoadBufferWidth(input)).toBe(0)
+    expect(computeContentWidth(input)).toBe(0)
+  })
+
+  it('timeshare → left buffer 0, content = max(viewWidth, 1) with no left buffer', () => {
+    const input = baseInput({ period: 'timeshare', dataLength: 50, viewWidth: 800 })
+    expect(computeLeftLoadBufferWidth(input)).toBe(0)
+    expect(computeContentWidth(input)).toBe(Math.max(800, 1))
+
+    const narrow = baseInput({ period: 'timeshare', dataLength: 10, viewWidth: 0 })
+    expect(computeLeftLoadBufferWidth(narrow)).toBe(0)
+    expect(computeContentWidth(narrow)).toBe(1)
+  })
+
+  it('kline with data → left buffer = Math.round(viewWidth)', () => {
+    const input = baseInput({ dataLength: 100, period: 'daily', viewWidth: 800.4 })
+    expect(computeLeftLoadBufferWidth(input)).toBe(Math.round(800.4))
+  })
+
+  it('kline contentWidth uses SCROLL_TRAILING_SLOTS (30) historical formula', () => {
+    expect(SCROLL_TRAILING_SLOTS).toBe(30)
+
+    const input = baseInput({
+      dataLength: 100,
+      period: 'daily',
+      viewWidth: 800,
+      dpr: 2,
+      kWidth: 8,
+      kGap: 2,
+    })
+    const left = computeLeftLoadBufferWidth(input)
+    const { startXPx, unitPx } = getPhysicalKLineConfig(input.kWidth, input.kGap, input.dpr)
+    const dataPlotWidth =
+      (startXPx + (input.dataLength + SCROLL_TRAILING_SLOTS) * unitPx) / input.dpr
+    const expected = left + Math.max(dataPlotWidth, input.viewWidth)
+
+    expect(computeContentWidth(input)).toBe(expected)
+  })
+
+  it('computeMaxScrollLeft = max(0, contentWidth - viewWidth)', () => {
+    expect(computeMaxScrollLeft(1200, 800)).toBe(400)
+    expect(computeMaxScrollLeft(500, 800)).toBe(0)
+    expect(computeMaxScrollLeft(800, 800)).toBe(0)
+  })
+})

package/src/engine/data/__tests__/scrollCompensator.geometry.test.ts

@@ -0,0 +1,184 @@
+import { describe, expect, it } from 'vitest'
+
+import type { ChartDom, Viewport } from '../../chartTypes'
+import { getPhysicalKLineConfig } from '../../utils/klineConfig'
+import {
+  computeContentWidth,
+  computeLeftLoadBufferWidth,
+  computeMaxScrollLeft,
+} from '../../state/contentGeometry'
+import { ScrollCompensator, type ScrollDeps } from '../scrollCompensator'
+
+function makeDom(): ChartDom {
+  return {
+    container: { clientWidth: 800 } as HTMLDivElement,
+    scrollContent: undefined,
+  }
+}
+
+function makeDeps(options: {
+  scrollLeft?: number
+  leftBuffer?: number
+  contentWidth?: number
+  viewWidth?: number
+  dataLength?: number
+} = {}): { deps: ScrollDeps; getScrollLeft: () => number } {
+  let scrollLeft = options.scrollLeft ?? 0
+  const viewWidth = options.viewWidth ?? 800
+  const dataLength = options.dataLength ?? 100
+  const kWidth = 8
+  const kGap = 2
+  const dpr = 1
+  const period = 'daily'
+  const leftBuffer =
+    options.leftBuffer ??
+    computeLeftLoadBufferWidth({
+      viewWidth,
+      plotWidth: viewWidth,
+      dataLength,
+      period,
+      dpr,
+      kWidth,
+      kGap,
+    })
+  const contentWidth =
+    options.contentWidth ??
+    computeContentWidth({
+      viewWidth,
+      plotWidth: viewWidth,
+      dataLength,
+      period,
+      dpr,
+      kWidth,
+      kGap,
+    })
+
+  const viewport: Viewport = {
+    viewWidth,
+    viewHeight: 600,
+    plotWidth: viewWidth,
+    plotHeight: 600,
+    scrollLeft,
+    dpr,
+  }
+
+  const deps: ScrollDeps = {
+    getOption: () => ({ kWidth, kGap }),
+    getEffectiveDpr: () => dpr,
+    getCachedScrollLeft: () => scrollLeft,
+    setScrollLeft: (v) => {
+      scrollLeft = v
+    },
+    getDom: () => makeDom(),
+    getObservedSize: () => ({ width: viewWidth, height: 600 }),
+    getViewport: () => viewport,
+    getLeftLoadBufferWidth: () => leftBuffer,
+    getContentWidth: () => contentWidth,
+  }
+
+  return {
+    deps,
+    getScrollLeft: () => scrollLeft,
+  }
+}
+
+describe('ScrollCompensator geometry SSOT', () => {
+  it('scrollToRight clamps target to maxScrollLeft from injected contentWidth', () => {
+    const dataLength = 200
+    const viewWidth = 400
+    const kWidth = 8
+    const kGap = 2
+    const dpr = 1
+    const input = {
+      viewWidth,
+      plotWidth: viewWidth,
+      dataLength,
+      period: 'daily',
+      dpr,
+      kWidth,
+      kGap,
+    }
+    const leftBuffer = computeLeftLoadBufferWidth(input)
+    const contentWidth = computeContentWidth(input)
+    const maxScroll = computeMaxScrollLeft(contentWidth, viewWidth)
+
+    const { deps, getScrollLeft } = makeDeps({
+      viewWidth,
+      dataLength,
+      leftBuffer,
+      contentWidth,
+      scrollLeft: 0,
+    })
+
+    const compensator = new ScrollCompensator(deps)
+    compensator.scrollToRight(dataLength)
+
+    const scrollLeft = getScrollLeft()
+    expect(scrollLeft).toBeLessThanOrEqual(maxScroll)
+    expect(scrollLeft).toBeGreaterThanOrEqual(0)
+
+    // target 计算应与 clamp 后一致（数据足够长时贴右）
+    const { unitPx, startXPx } = getPhysicalKLineConfig(kWidth, kGap, dpr)
+    const lastKLineEndPx = (startXPx + dataLength * unitPx) / dpr
+    const rawTarget = leftBuffer + (lastKLineEndPx - viewWidth)
+    const expected = Math.round(Math.max(0, Math.min(rawTarget, maxScroll)) * dpr) / dpr
+    expect(scrollLeft).toBe(expected)
+  })
+
+  it('scrollToRight uses deps.getContentWidth / getLeftLoadBufferWidth, not local formulas', () => {
+    const injectedLeft = 111
+    const injectedContent = 500
+    const viewWidth = 400
+    let scrollLeft = 0
+
+    const deps: ScrollDeps = {
+      getOption: () => ({ kWidth: 8, kGap: 2 }),
+      getEffectiveDpr: () => 1,
+      getCachedScrollLeft: () => scrollLeft,
+      setScrollLeft: (v) => {
+        scrollLeft = v
+      },
+      getDom: () => makeDom(),
+      getObservedSize: () => ({ width: viewWidth, height: 600 }),
+      getViewport: () => ({
+        viewWidth,
+        viewHeight: 600,
+        plotWidth: viewWidth,
+        plotHeight: 600,
+        scrollLeft: 0,
+        dpr: 1,
+      }),
+      getLeftLoadBufferWidth: () => injectedLeft,
+      getContentWidth: () => injectedContent,
+    }
+
+    const compensator = new ScrollCompensator(deps)
+    compensator.scrollToRight(50)
+
+    const maxScroll = Math.max(0, injectedContent - viewWidth)
+    expect(scrollLeft).toBeLessThanOrEqual(maxScroll)
+    // leftBuffer 来自注入值，目标会基于 111 计算并 clamp
+    expect(scrollLeft).toBe(maxScroll)
+  })
+
+  it('adjustScrollAfterDataChange uses injected left buffer when scrollLeft <= 0', () => {
+    let scrollLeft = 0
+    const injectedLeft = 640
+    const deps: ScrollDeps = {
+      getOption: () => ({ kWidth: 8, kGap: 2 }),
+      getEffectiveDpr: () => 1,
+      getCachedScrollLeft: () => scrollLeft,
+      setScrollLeft: (v) => {
+        scrollLeft = v
+      },
+      getDom: () => makeDom(),
+      getObservedSize: () => ({ width: 800, height: 600 }),
+      getViewport: () => null,
+      getLeftLoadBufferWidth: () => injectedLeft,
+      getContentWidth: () => 2000,
+    }
+
+    new ScrollCompensator(deps).adjustScrollAfterDataChange(10)
+    expect(scrollLeft).toBe(injectedLeft)
+  })
+})