@363045841yyt/klinechart-core 0.9.0-alpha.2 → 0.9.0-alpha.4

package/src/engine/layout/chartPaneLayout.ts

@@ -2,6 +2,8 @@ import type { PaneRole } from '../../foundation/plugin/index'
 import type { ChartDom, PaneSpec, Viewport } from '../chartTypes'
 import { PaneRenderer } from '../paneRenderer'
 import type { ScaleType } from '../utils/tickPosition'
+import type { PaneStateModule } from '../state/paneState'
+import type { ViewportStateModule } from '../state/viewportState'
 
 import { Pane, UpdateLevel } from './pane'
 import { normalizeVisiblePaneRatios as pureNormalizeVisiblePaneRatios } from './paneRatioMath'
@@ -16,14 +18,15 @@ export interface PaneLayoutDependencies {
     paneGap?: number
     defaultPaneMinHeightPx?: number
   }
-  getViewport: () => Viewport | null
+  /** scroll / plot 几何 SSOT */
+  viewport: ViewportStateModule
   setKnownPaneIds: (ids: string[]) => void
   notifyPaneResize: (paneId: string, pane: Pane) => void
   scheduleDraw: (level?: UpdateLevel) => void
-  getPaneRatios: () => Record<string, number>
-  /** kernel.paneScaleTypes 投影源；initPanes 优先于此 */
-  getPaneScaleTypes: () => ReadonlyMap<string, ScaleType>
-  commitLayout: (ratios: Record<string, number>, specs: PaneSpec[]) => void
+  /** pane ratios / specs / scaleTypes SSOT */
+  pane: PaneStateModule
+  /** commitLayout 写入 kernel 后的副作用（如 ensurePaneScaleTypes） */
+  afterCommitLayout?: () => void
 }
 
 /**
@@ -63,7 +66,7 @@ export class ChartPaneLayout {
    * 公共读：specs 结构来自工作副本定义，ratio 字段取自 kernel（不写工作副本）。
    */
   getPaneSpecs(): PaneSpec[] {
-    const kernelRatios = this.deps.getPaneRatios()
+    const kernelRatios = this.deps.pane.readonly.paneRatios.peek()
     return this._paneSpecs.map((spec) => ({
       ...spec,
       ratio: kernelRatios[spec.id] ?? spec.ratio,
@@ -75,11 +78,11 @@ export class ChartPaneLayout {
    * 公共读：直接返回 kernel paneRatios 副本，不触碰算法工作副本。
    */
   getInternalPaneRatios(): Map<string, number> {
-    return new Map(Object.entries(this.deps.getPaneRatios()))
+    return new Map(Object.entries(this.deps.pane.readonly.paneRatios.peek()))
   }
 
   private syncRatiosFromKernel(): void {
-    const kernelRatios = this.deps.getPaneRatios()
+    const kernelRatios = this.deps.pane.readonly.paneRatios.peek()
     this._internalPaneRatios = new Map(Object.entries(kernelRatios))
   }
 
@@ -100,17 +103,36 @@ export class ChartPaneLayout {
     return index === 0 ? 'price' : 'indicator'
   }
 
-  private createAxisCanvas(spec: PaneSpec, pane: Pane, side: 'left' | 'right'): HTMLCanvasElement {
+  private createAxisCanvas(
+    spec: PaneSpec,
+    side: 'left' | 'right',
+    kind: 'base' | 'overlay' = 'base',
+  ): HTMLCanvasElement {
     const canvas = document.createElement('canvas')
-    canvas.id = `${spec.id}-${side}Axis`
-    canvas.className = side === 'right' ? 'right-axis' : 'left-axis'
+    const isRight = side === 'right'
+    const isOverlay = kind === 'overlay'
+    canvas.id = `${spec.id}-${side}Axis${isOverlay ? 'Overlay' : ''}`
+    canvas.className = isRight
+      ? isOverlay
+        ? 'right-axis-overlay'
+        : 'right-axis'
+      : isOverlay
+        ? 'left-axis-overlay'
+        : 'left-axis'
     canvas.style.position = 'absolute'
     canvas.style.left = '0'
+    if (isOverlay) {
+      canvas.style.pointerEvents = 'none'
+      canvas.style.backgroundColor = 'transparent'
+      canvas.style.zIndex = '1'
+    } else {
+      canvas.style.zIndex = '0'
+    }
     return canvas
   }
 
   private initPanes() {
-    const kernelScaleTypes = this.deps.getPaneScaleTypes()
+    const kernelScaleTypes = this.deps.pane.readonly.paneScaleTypes.peek()
     const prevScaleTypes = new Map<string, ScaleType>()
     for (const r of this.paneRenderers) {
       prevScaleTypes.set(r.getPane().id, r.getPane().yAxis.getScaleType())
@@ -129,7 +151,8 @@ export class ChartPaneLayout {
 
       const mainCanvas = document.createElement('canvas')
       const overlayCanvas = document.createElement('canvas')
-      const yAxisCanvas = this.createAxisCanvas(spec, pane, 'right')
+      const yAxisCanvas = this.createAxisCanvas(spec, 'right', 'base')
+      const yAxisOverlayCanvas = this.createAxisCanvas(spec, 'right', 'overlay')
 
       const isMain = pane.role === 'price'
 
@@ -149,10 +172,18 @@ export class ChartPaneLayout {
       overlayCanvas.style.backgroundColor = 'transparent'
       overlayCanvas.style.zIndex = '2'
 
-      const leftYAxisCanvas = this.createAxisCanvas(spec, pane, 'left')
+      const leftYAxisCanvas = this.createAxisCanvas(spec, 'left', 'base')
+      const leftYAxisOverlayCanvas = this.createAxisCanvas(spec, 'left', 'overlay')
 
       const renderer = new PaneRenderer(
-        { mainCanvas, overlayCanvas, yAxisCanvas, leftYAxisCanvas },
+        {
+          mainCanvas,
+          overlayCanvas,
+          yAxisCanvas,
+          yAxisOverlayCanvas,
+          leftYAxisCanvas,
+          leftYAxisOverlayCanvas,
+        },
         pane,
         {
           rightAxisWidth: this.deps.getOption().rightAxisWidth,
@@ -177,11 +208,15 @@ export class ChartPaneLayout {
       existingCanvases.forEach((canvas) => canvas.remove())
     }
     if (rightAxisLayer) {
-      const existingAxisCanvases = rightAxisLayer.querySelectorAll('canvas.right-axis')
+      const existingAxisCanvases = rightAxisLayer.querySelectorAll(
+        'canvas.right-axis, canvas.right-axis-overlay',
+      )
       existingAxisCanvases.forEach((canvas) => canvas.remove())
     }
     if (leftAxisLayer) {
-      const existingLeftAxisCanvases = leftAxisLayer.querySelectorAll('canvas.left-axis')
+      const existingLeftAxisCanvases = leftAxisLayer.querySelectorAll(
+        'canvas.left-axis, canvas.left-axis-overlay',
+      )
       existingLeftAxisCanvases.forEach((canvas) => canvas.remove())
     }
 
@@ -190,8 +225,12 @@ export class ChartPaneLayout {
       canvasLayer.appendChild(domEls.mainCanvas)
       canvasLayer.appendChild(domEls.overlayCanvas)
       rightAxisLayer.appendChild(domEls.yAxisCanvas)
+      rightAxisLayer.appendChild(domEls.yAxisOverlayCanvas)
       if (leftAxisLayer && domEls.leftYAxisCanvas) {
         leftAxisLayer.appendChild(domEls.leftYAxisCanvas)
+        if (domEls.leftYAxisOverlayCanvas) {
+          leftAxisLayer.appendChild(domEls.leftYAxisOverlayCanvas)
+        }
       }
     })
 
@@ -299,10 +338,16 @@ export class ChartPaneLayout {
     return heights
   }
 
+  /** viewWidth 为 0 表示尚未完成首帧尺寸 */
+  private peekViewport(): Viewport | null {
+    if (this.deps.viewport.readonly.viewWidth.peek() === 0) return null
+    return this.deps.viewport.readonly.viewport.peek()
+  }
+
   layoutPanes(options?: { commit?: boolean }) {
     this.syncRatiosFromKernel()
 
-    const vp = this.deps.getViewport()
+    const vp = this.peekViewport()
     if (!vp) return
 
     const visibleSpecs = this._paneSpecs.filter((p) => p.visible !== false)
@@ -338,10 +383,16 @@ export class ChartPaneLayout {
       domEls.overlayCanvas.style.top = `${y}px`
       domEls.yAxisCanvas.style.top = `${y}px`
       domEls.yAxisCanvas.style.left = '0px'
+      domEls.yAxisOverlayCanvas.style.top = `${y}px`
+      domEls.yAxisOverlayCanvas.style.left = '0px'
       if (domEls.leftYAxisCanvas) {
         domEls.leftYAxisCanvas.style.top = `${y}px`
         domEls.leftYAxisCanvas.style.left = '0px'
       }
+      if (domEls.leftYAxisOverlayCanvas) {
+        domEls.leftYAxisOverlayCanvas.style.top = `${y}px`
+        domEls.leftYAxisOverlayCanvas.style.left = '0px'
+      }
 
       y += h + gap
     }
@@ -388,7 +439,7 @@ export class ChartPaneLayout {
    * commitLayout 走 buildLayoutSpecsFromWorkingCopy，避免公共读污染算法中间态。
    */
   getPaneLayoutSpecs(): PaneSpec[] {
-    return this.buildLayoutSpecs(this.deps.getPaneRatios())
+    return this.buildLayoutSpecs(this.deps.pane.readonly.paneRatios.peek())
   }
 
   /** 仅算法/commit 使用：读当前工作副本 ratios，不读 kernel */
@@ -422,7 +473,8 @@ export class ChartPaneLayout {
     this._internalPaneRatios.forEach((ratio, id) => {
       ratios[id] = ratio
     })
-    this.deps.commitLayout(ratios, this.buildLayoutSpecsFromWorkingCopy())
+    this.deps.pane.actions.commitLayout(ratios, this.buildLayoutSpecsFromWorkingCopy())
+    this.deps.afterCommitLayout?.()
   }
 
   applyPaneLayoutSpecs(panes: PaneSpec[], options?: { preferIncomingRatios?: boolean }): void {
@@ -499,7 +551,7 @@ export class ChartPaneLayout {
 
   resizePaneBoundary(upperPaneId: string, deltaY: number): boolean {
     if (!Number.isFinite(deltaY) || deltaY === 0) return false
-    const vp = this.deps.getViewport()
+    const vp = this.peekViewport()
     if (!vp) return false
 
     this.syncRatiosFromKernel()

package/src/engine/modes/__tests__/timeShareMath.test.ts

@@ -0,0 +1,185 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  resolveTimeShareSlotTimestamp,
+  timeShareSlotCenterX,
+} from '../../../foundation/utils/timeShareAxisLabels'
+import {
+  ASHARE_TIMESHARE_SESSION_SLOTS,
+  computeTimeShareBarMetrics,
+  computeTimeSharePaneLayout,
+  computeTimeSharePriceRange,
+  computeTimeShareTimeLabelIndices,
+  computeTimeShareXLayout,
+  resolveTimeShareSessionSlots,
+  resolveTimeShareBaseline,
+} from '../timeShareMath'
+
+describe('resolveTimeShareBaseline', () => {
+  it('prefers finite non-zero preClose over first trade price', () => {
+    expect(resolveTimeShareBaseline({ preClose: 10.5, firstPrice: 11 })).toBe(10.5)
+  })
+
+  it('falls back to first price when preClose is missing or zero', () => {
+    expect(resolveTimeShareBaseline({ preClose: 0, firstPrice: 11 })).toBe(11)
+    expect(resolveTimeShareBaseline({ firstPrice: 11 })).toBe(11)
+    expect(resolveTimeShareBaseline({ preClose: null, firstPrice: 9 })).toBe(9)
+  })
+
+  it('returns null when no valid baseline exists', () => {
+    expect(resolveTimeShareBaseline({ preClose: 0, firstPrice: 0 })).toBeNull()
+    expect(resolveTimeShareBaseline({})).toBeNull()
+    expect(resolveTimeShareBaseline({ preClose: NaN, firstPrice: Infinity })).toBeNull()
+  })
+})
+
+describe('computeTimeSharePriceRange', () => {
+  it('uses preClose baseline and pads around max absolute percent move', () => {
+    // open gap up: first trade 11, preClose 10 → +10%; later 10.5 → 5%
+    const range = computeTimeSharePriceRange([11, 10.5, 10.2], 10)
+    expect(range).not.toBeNull()
+    // maxAbsPct=10, padding=max(1, 0.5)=1 → display 11%
+    expect(range!.maxPrice).toBeCloseTo(10 * 1.11, 8)
+    expect(range!.minPrice).toBeCloseTo(10 * 0.89, 8)
+  })
+
+  it('still applies minimum padding when all prices equal baseline (flat day)', () => {
+    const range = computeTimeSharePriceRange([10, 10, 10], 10)
+    expect(range).not.toBeNull()
+    // maxAbsPct=0, padding=min 0.5% → ±0.5%
+    expect(range!.maxPrice).toBeCloseTo(10.05, 8)
+    expect(range!.minPrice).toBeCloseTo(9.95, 8)
+  })
+
+  it('returns null for invalid baseline', () => {
+    expect(computeTimeSharePriceRange([10], 0)).toBeNull()
+    expect(computeTimeSharePriceRange([10], NaN)).toBeNull()
+  })
+})
+
+describe('resolveTimeShareSessionSlots', () => {
+  it('defaults to A-share 240 one-minute slots (sessions SSOT)', () => {
+    expect(ASHARE_TIMESHARE_SESSION_SLOTS).toBe(240)
+    expect(resolveTimeShareSessionSlots(0)).toBe(240)
+    expect(resolveTimeShareSessionSlots(60)).toBe(240)
+  })
+
+  it('does not expand when arrived points exceed session slots', () => {
+    expect(resolveTimeShareSessionSlots(300)).toBe(240)
+  })
+})
+
+describe('computeTimeShareBarMetrics', () => {
+  it('divides viewWidth by full session slots, not arrived point count', () => {
+    // 盘中仅 60 点：宽度仍按 240 槽划分，不把 60 点拉满屏
+    const partial = computeTimeShareBarMetrics(60, 320, 1)
+    const full = computeTimeShareBarMetrics(240, 320, 1)
+    expect(partial).not.toBeNull()
+    expect(full).not.toBeNull()
+    expect(partial!.kWidth).toBeCloseTo(full!.kWidth, 8)
+    expect(partial!.kGap).toBeCloseTo(full!.kGap, 8)
+    expect((partial!.kWidth + partial!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('fits full session into viewWidth even when per-bar width is sub-pixel (DPR=1 narrow)', () => {
+    const m = computeTimeShareBarMetrics(240, 320, 1)
+    expect(m).not.toBeNull()
+    const unit = m!.kWidth + m!.kGap
+    expect(unit * 240).toBeCloseTo(320, 6)
+    expect(m!.kWidth).toBeGreaterThan(0)
+    expect(m!.kGap).toBeGreaterThanOrEqual(0)
+  })
+
+  it('keeps full session visible at high DPR', () => {
+    const m = computeTimeShareBarMetrics(240, 320, 2)
+    expect(m).not.toBeNull()
+    expect((m!.kWidth + m!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('returns null for empty data or invalid width', () => {
+    expect(computeTimeShareBarMetrics(0, 320, 1)).toBeNull()
+    expect(computeTimeShareBarMetrics(10, 0, 1)).toBeNull()
+  })
+})
+
+describe('computeTimeShareXLayout', () => {
+  it('places partial-day points on session timeline leaving right-side blank', () => {
+    const layout = computeTimeShareXLayout({
+      arrivedCount: 60,
+      sessionSlots: 240,
+      totalWidth: 480,
+      dpr: 1,
+    })
+    expect(layout).not.toBeNull()
+    // step = 480/240 = 2；第 0 点中心 1，第 59 点中心 119，未到右缘 480
+    expect(layout!.centers[0]).toBeCloseTo(1, 6)
+    expect(layout!.centers[59]).toBeCloseTo(119, 6)
+    expect(layout!.centers[59]!).toBeLessThan(480 * 0.3)
+    expect(layout!.step).toBeCloseTo(2, 6)
+  })
+
+  it('fills full width only when arrivedCount covers full session', () => {
+    const layout = computeTimeShareXLayout({
+      arrivedCount: 240,
+      sessionSlots: 240,
+      totalWidth: 480,
+      dpr: 1,
+    })
+    expect(layout).not.toBeNull()
+    expect(layout!.centers[0]).toBeCloseTo(1, 6)
+    expect(layout!.centers[239]).toBeCloseTo(479, 6)
+  })
+})
+
+describe('computeTimeSharePaneLayout', () => {
+  it('splits price area above volume area without overlap', () => {
+    const layout = computeTimeSharePaneLayout(400, 0.25)
+    expect(layout.priceAreaHeight).toBe(300)
+    expect(layout.volumeAreaHeight).toBe(100)
+    expect(layout.priceTop).toBe(0)
+    expect(layout.volumeTop).toBe(300)
+    expect(layout.priceTop + layout.priceAreaHeight).toBe(layout.volumeTop)
+  })
+})
+
+describe('computeTimeShareTimeLabelIndices', () => {
+  it('only session closed-side endpoints: 9:30 / 13:00 / 15:00', () => {
+    const labels = computeTimeShareTimeLabelIndices({
+      axisWidth: 800,
+      sessionSlots: 240,
+    })
+    // 9:30 → 0；13:00 → 120；15:00 → 239
+    expect(labels).toEqual([0, 120, 239])
+  })
+
+  it('returns empty for invalid axis width', () => {
+    expect(
+      computeTimeShareTimeLabelIndices({
+        axisWidth: 0,
+        sessionSlots: 240,
+      }),
+    ).toEqual([])
+  })
+})
+
+describe('timeShare slot time/x helpers', () => {
+  it('maps A-share slots across lunch break', () => {
+    // 2026-07-21 local
+    const day = new Date(2026, 6, 21, 10, 0, 0, 0).getTime()
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 0)).getHours()).toBe(9)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 0)).getMinutes()).toBe(30)
+    // slot 120 = 13:00
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 120)).getHours()).toBe(13)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 120)).getMinutes()).toBe(0)
+    // slot 239 = 14:59
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 239)).getHours()).toBe(14)
+    expect(new Date(resolveTimeShareSlotTimestamp(day, 239)).getMinutes()).toBe(59)
+  })
+
+  it('places last session slot near right edge of axis', () => {
+    const x0 = timeShareSlotCenterX(0, 480, 240, 1)
+    const xLast = timeShareSlotCenterX(239, 480, 240, 1)
+    expect(x0).toBeCloseTo(1, 6)
+    expect(xLast).toBeCloseTo(479, 6)
+  })
+})

package/src/engine/modes/__tests__/timeShareMode.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { Pane } from '../../layout/pane'
+import { TimeShareMode } from '../timeShareMode'
+import type { TimeShareData } from '../../../foundation/types/price'
+
+function ts(price: number, i = 0): TimeShareData {
+  return { timestamp: i, price, average: price, volume: 1, amount: price }
+}
+
+function mockDm(points: TimeShareData[], preClose: number | null = null) {
+  return {
+    getTimeShareData: () => points,
+    getTimeSharePreClose: () => preClose,
+  } as unknown as import('../../data/chartDataManager').ChartDataManager
+}
+
+describe('TimeShareMode', () => {
+  it('computeKWidth fits full session into narrow view (no DPR truncation)', () => {
+    const mode = new TimeShareMode()
+    const m = mode.computeKWidth(240, 320, 1)
+    expect(m).not.toBeNull()
+    expect((m!.kWidth + m!.kGap) * 240).toBeCloseTo(320, 6)
+  })
+
+  it('computeKWidth for partial day matches full-session bar size', () => {
+    const mode = new TimeShareMode()
+    const partial = mode.computeKWidth(60, 320, 1)
+    const full = mode.computeKWidth(240, 320, 1)
+    expect(partial).not.toBeNull()
+    expect(full).not.toBeNull()
+    expect(partial!.kWidth).toBeCloseTo(full!.kWidth, 8)
+    expect(partial!.kGap).toBeCloseTo(full!.kGap, 8)
+  })
+
+  it('setMarketSession switches bar metrics to HK 330 slots', () => {
+    const mode = new TimeShareMode()
+    const ashare = mode.computeKWidth(100, 330, 1)!
+    mode.setMarketSession({
+      timeZone: 'Asia/Hong_Kong',
+      sessions: [
+        { open: 9 * 60 + 30, close: 12 * 60 },
+        { open: 13 * 60, close: 16 * 60 },
+      ],
+      slotMinutes: 1,
+    })
+    const hk = mode.computeKWidth(100, 330, 1)!
+    // A 股 240 槽 unit=330/240；港股 330 槽 unit=1
+    expect(ashare.kWidth + ashare.kGap).toBeCloseTo(330 / 240, 6)
+    expect(hk.kWidth + hk.kGap).toBeCloseTo(1, 6)
+  })
+
+  it('updatePaneRange uses preClose as basePrice and covers open gap', () => {
+    const mode = new TimeShareMode()
+    const pane = new Pane('main')
+    const setBase = vi.spyOn(pane.yAxis, 'setBasePrice')
+    const setRange = vi.spyOn(pane.yAxis, 'setRange')
+
+    // open gap: first trade 11, preClose 10
+    mode.updatePaneRange(pane, { start: 0, end: 3 }, mockDm([ts(11), ts(10.5), ts(10.2)], 10))
+
+    expect(setBase).toHaveBeenCalledWith(10)
+    expect(setRange).toHaveBeenCalled()
+    const range = setRange.mock.calls[0]![0] as { minPrice: number; maxPrice: number }
+    // maxAbs 10% + 1% padding → ±11%
+    expect(range.maxPrice).toBeCloseTo(11.1, 6)
+    expect(range.minPrice).toBeCloseTo(8.9, 6)
+  })
+
+  it('updatePaneRange still sets range on flat day', () => {
+    const mode = new TimeShareMode()
+    const pane = new Pane('main')
+    const setRange = vi.spyOn(pane.yAxis, 'setRange')
+
+    mode.updatePaneRange(pane, { start: 0, end: 2 }, mockDm([ts(10), ts(10)], 10))
+    expect(setRange).toHaveBeenCalled()
+    const range = setRange.mock.calls[0]![0] as { minPrice: number; maxPrice: number }
+    expect(range.maxPrice).toBeCloseTo(10.05, 6)
+    expect(range.minPrice).toBeCloseTo(9.95, 6)
+  })
+})

package/src/engine/modes/timeShareMath.ts

@@ -0,0 +1,150 @@
+import {
+  ASHARE_MARKET_SESSION,
+  resolveMarketSessionSlots,
+  type MarketSessionConfig,
+} from '../../foundation/utils/timeShareAxisLabels'
+
+export type TimeShareBaselineInput = {
+  preClose?: number | null
+  firstPrice?: number | null
+}
+
+export function resolveTimeShareBaseline(input: TimeShareBaselineInput): number | null {
+  const candidates = [input.preClose, input.firstPrice]
+  for (const v of candidates) {
+    if (typeof v === 'number' && Number.isFinite(v) && v !== 0) return v
+  }
+  return null
+}
+
+export type TimeSharePriceRange = {
+  minPrice: number
+  maxPrice: number
+}
+
+/**
+ * 分时 Y 轴价格区间：以 baseline（昨收）为中心，对称覆盖可见最大绝对涨跌幅并加 padding。
+ * 全天平盘时仍保留最小 0.5% 边距，避免 range 退化。
+ */
+export function computeTimeSharePriceRange(
+  prices: ReadonlyArray<number | undefined | null>,
+  baseline: number,
+): TimeSharePriceRange | null {
+  if (!Number.isFinite(baseline) || baseline === 0) return null
+
+  let maxAbsPct = 0
+  for (const p of prices) {
+    if (typeof p !== 'number' || !Number.isFinite(p)) continue
+    const pct = Math.abs((p - baseline) / baseline) * 100
+    if (pct > maxAbsPct) maxAbsPct = pct
+  }
+
+  const padding = Math.max(maxAbsPct * 0.1, 0.5)
+  const displayPct = maxAbsPct + padding
+  return {
+    minPrice: baseline * (1 - displayPct / 100),
+    maxPrice: baseline * (1 + displayPct / 100),
+  }
+}
+
+/** A 股默认全天 1 分钟槽位数（兼容旧导出） */
+export const ASHARE_TIMESHARE_SESSION_SLOTS = resolveMarketSessionSlots(ASHARE_MARKET_SESSION)
+
+/**
+ * 全天交易槽位数：以 marketSession 为 SSOT，不因 arrivedCount 放大。
+ * @deprecated 优先用 resolveMarketSessionSlots(config)
+ */
+export function resolveTimeShareSessionSlots(
+  arrivedCount: number,
+  marketSession: MarketSessionConfig = ASHARE_MARKET_SESSION,
+): number {
+  void arrivedCount
+  return resolveMarketSessionSlots(marketSession)
+}
+
+/**
+ * 分时 bar 宽度：按全天 sessionSlots 均分 viewWidth，而非按已到达点数。
+ * 盘中部分数据时右侧留白；允许亚像素，避免窄屏截断。
+ */
+export function computeTimeShareBarMetrics(
+  dataLength: number,
+  viewWidth: number,
+  dpr: number,
+  marketSession: MarketSessionConfig = ASHARE_MARKET_SESSION,
+): { kWidth: number; kGap: number } | null {
+  if (dataLength <= 0 || viewWidth <= 0 || !(dpr > 0)) return null
+
+  const sessionSlots = resolveMarketSessionSlots(marketSession)
+  if (sessionSlots <= 0) return null
+  const unit = viewWidth / sessionSlots
+  const preferredGap = 1 / dpr
+  const kGap = Math.min(preferredGap, unit * 0.2)
+  const kWidth = Math.max(unit - kGap, unit * 0.01)
+  return { kWidth, kGap: unit - kWidth }
+}
+
+export type TimeShareXLayoutInput = {
+  arrivedCount: number
+  sessionSlots: number
+  totalWidth: number
+  dpr: number
+}
+
+export type TimeShareXLayout = {
+  step: number
+  centers: number[]
+  lefts: number[]
+  barWidth: number
+  kWidthPx: number
+}
+
+/**
+ * 分时 X 布局：step = totalWidth / sessionSlots，已到达点按 slot 索引落位，未到时段留白。
+ */
+export function computeTimeShareXLayout(input: TimeShareXLayoutInput): TimeShareXLayout | null {
+  const { arrivedCount, sessionSlots, totalWidth, dpr } = input
+  if (arrivedCount <= 0 || sessionSlots <= 0 || totalWidth <= 0 || !(dpr > 0)) return null
+
+  const step = totalWidth / sessionSlots
+  const centers: number[] = new Array(arrivedCount)
+  const lefts: number[] = new Array(arrivedCount)
+  for (let i = 0; i < arrivedCount; i++) {
+    centers[i] = Math.round((i + 0.5) * step * dpr) / dpr
+    lefts[i] = Math.round(i * step * dpr) / dpr
+  }
+
+  const logicalBarWidth = Math.max(step * 0.6, 1 / dpr)
+  const barWidthPx = Math.max(1, Math.round(logicalBarWidth * dpr))
+  const barWidth = barWidthPx / dpr
+  const kWidthPx = Math.max(1, Math.round(step * dpr))
+
+  return { step, centers, lefts, barWidth, kWidthPx }
+}
+
+export type TimeSharePaneLayout = {
+  priceTop: number
+  priceAreaHeight: number
+  volumeTop: number
+  volumeAreaHeight: number
+}
+
+export function computeTimeSharePaneLayout(
+  paneHeight: number,
+  volumeRatio: number,
+): TimeSharePaneLayout {
+  const ratio = Math.min(1, Math.max(0, volumeRatio))
+  const volumeAreaHeight = paneHeight * ratio
+  const priceAreaHeight = paneHeight - volumeAreaHeight
+  return {
+    priceTop: 0,
+    priceAreaHeight,
+    volumeTop: priceAreaHeight,
+    volumeAreaHeight,
+  }
+}
+
+export {
+  TIMESHARE_MIN_LABEL_SPACING_PX,
+  computeTimeShareTimeLabelIndices,
+  type TimeShareTimeLabelInput,
+} from '../../foundation/utils/timeShareAxisLabels'