@pgcorp/ui-kit 0.7.3 → 0.8.1

package/src/internal/chartGeometry.ts

@@ -0,0 +1,852 @@
+import type {
+  SChartBarMode,
+  SChartCategory,
+  SChartCurve,
+  SChartDataLabels,
+  SChartDomain,
+  SChartMarkers,
+  SChartRadialLabel,
+  SChartSeries,
+  SChartSize,
+  SChartTone,
+  SChartType,
+  SChartXLabels,
+} from '../components/shared/data-display/chart'
+
+const CHART_TONES = [
+  'series-1',
+  'series-2',
+  'series-3',
+  'series-4',
+  'series-5',
+  'series-6',
+  'series-7',
+  'series-8',
+  'success',
+  'warn',
+  'danger',
+] as const satisfies readonly SChartTone[]
+const DEFAULT_TONES = CHART_TONES.slice(0, 8)
+
+interface Point {
+  readonly x: number
+  readonly y: number
+  readonly value: number
+  readonly valueLabel: string
+  readonly categoryKey: string
+  readonly categoryLabel: string
+  readonly seriesKey: string
+  readonly seriesLabel: string
+  readonly tone: SChartTone
+  readonly title: string
+}
+
+export interface ChartLineModel {
+  readonly key: string
+  readonly label: string
+  readonly tone: SChartTone
+  readonly path: string
+  readonly areaPath: string
+  readonly points: readonly Point[]
+}
+
+export interface ChartBarModel extends Point {
+  readonly key: string
+  readonly width: number
+  readonly height: number
+}
+
+export interface ChartSliceModel {
+  readonly key: string
+  readonly label: string
+  readonly tone: SChartTone
+  readonly value: number
+  readonly valueLabel: string
+  readonly percentageLabel: string
+  readonly path: string
+  readonly labelX: number
+  readonly labelY: number
+  readonly dataLabel: string
+  readonly title: string
+}
+
+export interface ChartLegendItem {
+  readonly key: string
+  readonly label: string
+  readonly tone: SChartTone
+}
+
+export interface ChartTick {
+  readonly value: number
+  readonly label: string
+  readonly displayLabel: string
+  readonly position: number
+}
+
+export interface ChartCategoryLabel {
+  readonly key: string
+  readonly label: string
+  readonly lines: readonly string[]
+  readonly x: number
+  readonly textAnchor: 'start' | 'middle' | 'end'
+}
+
+export interface ChartGridLine {
+  readonly key: string
+  readonly x1: number
+  readonly x2: number
+  readonly y1: number
+  readonly y2: number
+}
+
+export interface ChartTableRow {
+  readonly key: string
+  readonly label: string
+  readonly values: readonly string[]
+}
+
+export interface ChartModel {
+  readonly width: number
+  readonly height: number
+  readonly plotX: number
+  readonly plotY: number
+  readonly plotWidth: number
+  readonly plotHeight: number
+  readonly baselineY: number
+  readonly empty: boolean
+  readonly emptyReason: 'no-data' | 'zero-total' | null
+  readonly lines: readonly ChartLineModel[]
+  readonly bars: readonly ChartBarModel[]
+  readonly slices: readonly ChartSliceModel[]
+  readonly horizontalGrid: readonly ChartGridLine[]
+  readonly verticalGrid: readonly ChartGridLine[]
+  readonly yTicks: readonly ChartTick[]
+  readonly xLabels: readonly ChartCategoryLabel[]
+  readonly legend: readonly ChartLegendItem[]
+  readonly tableRows: readonly ChartTableRow[]
+  readonly centerX: number
+  readonly centerY: number
+}
+
+export interface ResolveChartModelInput {
+  readonly type: SChartType
+  readonly size: SChartSize
+  readonly categories: readonly SChartCategory[]
+  readonly series: readonly SChartSeries[]
+  readonly domain: SChartDomain
+  readonly xAxis: boolean
+  readonly yAxis: boolean
+  readonly xLabels: SChartXLabels
+  readonly yTickCount: number
+  readonly curve: SChartCurve
+  readonly barMode: SChartBarMode
+  readonly dataLabels: SChartDataLabels
+  readonly markers: SChartMarkers
+  readonly radialLabel: SChartRadialLabel
+  readonly valueFormatter: (value: number) => string
+  /** Фактическая CSS-геометрия viewport сохраняет readable SVG typography при resize. / Actual CSS viewport geometry keeps SVG typography readable while resizing. */
+  readonly dimensions?: ChartDimensions
+}
+
+export interface ChartDimensions {
+  readonly width: number
+  readonly height: number
+}
+
+interface PlotRect {
+  readonly x: number
+  readonly y: number
+  readonly width: number
+  readonly height: number
+}
+
+interface ResolvedDomain {
+  readonly minimum: number
+  readonly maximum: number
+  readonly ticks: readonly number[]
+}
+
+const SIZE_DIMENSIONS: Readonly<Record<SChartSize, ChartDimensions>> = {
+  compact: { width: 360, height: 96 },
+  sm: { width: 640, height: 240 },
+  md: { width: 800, height: 360 },
+  lg: { width: 1000, height: 480 },
+}
+
+function resolveDimensions(size: SChartSize, candidate: ChartDimensions | undefined): ChartDimensions {
+  if (candidate === undefined) return SIZE_DIMENSIONS[size]
+  const dimensions = requireRecord(candidate, 'dimensions')
+  assertExactKeys(dimensions, ['width', 'height'], 'dimensions')
+  const width = requireFiniteNumber(dimensions.width, 'dimensions.width')
+  const height = requireFiniteNumber(dimensions.height, 'dimensions.height')
+  if (width <= 0 || height <= 0) fail('dimensions требует width и height больше нуля')
+  return { width, height }
+}
+
+function fail(message: string): never {
+  throw new TypeError(`SChart: ${message}`)
+}
+
+function assertExactKeys(
+  value: Record<string, unknown>,
+  allowed: readonly string[],
+  coordinate: string,
+): void {
+  const unexpected = Object.keys(value).filter((key) => !allowed.includes(key))
+  if (unexpected.length > 0) fail(`${coordinate} не допускает поля ${unexpected.join(', ')}`)
+}
+
+function requireRecord(value: unknown, coordinate: string): Record<string, unknown> {
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+    fail(`${coordinate} должен быть object`)
+  }
+  return value as Record<string, unknown>
+}
+
+function requireString(value: unknown, coordinate: string): string {
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    fail(`${coordinate} должен быть непустой строкой`)
+  }
+  return value
+}
+
+function requireTone(value: unknown, coordinate: string): SChartTone | undefined {
+  if (value === undefined) return undefined
+  if (typeof value !== 'string' || !CHART_TONES.includes(value as SChartTone)) {
+    fail(`${coordinate} должен быть semantic chart tone`)
+  }
+  return value as SChartTone
+}
+
+function requireFiniteNumber(value: unknown, coordinate: string): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) {
+    fail(`${coordinate} должен быть конечным числом`)
+  }
+  return value
+}
+
+function validateCategories(value: unknown): readonly SChartCategory[] {
+  if (!Array.isArray(value)) fail('categories должен быть массивом')
+  const keys = new Set<string>()
+  return value.map((candidate, index) => {
+    const category = requireRecord(candidate, `categories[${index}]`)
+    assertExactKeys(category, ['key', 'label', 'tone'], `categories[${index}]`)
+    const key = requireString(category.key, `categories[${index}].key`)
+    if (keys.has(key)) fail(`categories содержит повторный key ${JSON.stringify(key)}`)
+    keys.add(key)
+    return {
+      key,
+      label: requireString(category.label, `categories[${index}].label`),
+      tone: requireTone(category.tone, `categories[${index}].tone`),
+    }
+  })
+}
+
+function validateSeries(value: unknown, categoryCount: number): readonly SChartSeries[] {
+  if (!Array.isArray(value)) fail('series должен быть массивом')
+  const keys = new Set<string>()
+  return value.map((candidate, seriesIndex) => {
+    const series = requireRecord(candidate, `series[${seriesIndex}]`)
+    assertExactKeys(series, ['key', 'label', 'values', 'tone'], `series[${seriesIndex}]`)
+    const key = requireString(series.key, `series[${seriesIndex}].key`)
+    if (keys.has(key)) fail(`series содержит повторный key ${JSON.stringify(key)}`)
+    keys.add(key)
+    if (!Array.isArray(series.values)) fail(`series[${seriesIndex}].values должен быть массивом`)
+    if (series.values.length !== categoryCount) {
+      fail(`series[${seriesIndex}].values содержит ${series.values.length} значений для ${categoryCount} categories`)
+    }
+    return {
+      key,
+      label: requireString(series.label, `series[${seriesIndex}].label`),
+      values: series.values.map((item, valueIndex) => requireFiniteNumber(
+        item,
+        `series[${seriesIndex}].values[${valueIndex}]`,
+      )),
+      tone: requireTone(series.tone, `series[${seriesIndex}].tone`),
+    }
+  })
+}
+
+function formatValue(formatter: (value: number) => string, value: number, coordinate: string): string {
+  const label = formatter(value)
+  if (typeof label !== 'string' || label.trim().length === 0) {
+    fail(`valueFormatter вернул пустое значение для ${coordinate}`)
+  }
+  return label
+}
+
+function resolveTone(explicit: SChartTone | undefined, index: number): SChartTone {
+  return explicit ?? DEFAULT_TONES[index % DEFAULT_TONES.length]!
+}
+
+function niceStep(rawStep: number): number {
+  const exponent = Math.floor(Math.log10(rawStep))
+  const magnitude = 10 ** exponent
+  const fraction = rawStep / magnitude
+  const niceFraction = fraction <= 1 ? 1 : fraction <= 2 ? 2 : fraction <= 5 ? 5 : 10
+  return niceFraction * magnitude
+}
+
+function resolveDomain(
+  domain: SChartDomain,
+  values: readonly number[],
+  includeZeroDefault: boolean,
+  tickCount: number,
+): { readonly minimum: number; readonly maximum: number; readonly ticks: readonly number[] } {
+  const record = requireRecord(domain, 'domain')
+  if (record.mode === 'fixed') {
+    assertExactKeys(record, ['mode', 'minimum', 'maximum'], 'domain')
+    const minimum = requireFiniteNumber(record.minimum, 'domain.minimum')
+    const maximum = requireFiniteNumber(record.maximum, 'domain.maximum')
+    if (minimum >= maximum) fail('domain fixed требует minimum < maximum')
+    const outside = values.find((value) => value < minimum || value > maximum)
+    if (outside !== undefined) fail(`domain fixed [${minimum}, ${maximum}] не содержит value ${outside}`)
+    const step = (maximum - minimum) / (tickCount - 1)
+    return {
+      minimum,
+      maximum,
+      ticks: Array.from({ length: tickCount }, (_, index) => minimum + step * index),
+    }
+  }
+  if (record.mode !== 'auto') fail(`неизвестный domain.mode ${JSON.stringify(record.mode)}`)
+  assertExactKeys(record, ['mode', 'includeZero'], 'domain')
+  if (record.includeZero !== undefined && typeof record.includeZero !== 'boolean') {
+    fail('domain.includeZero должен быть boolean')
+  }
+  const includeZero = (record.includeZero as boolean | undefined) ?? includeZeroDefault
+  let minimum = Math.min(...values)
+  let maximum = Math.max(...values)
+  if (includeZero) {
+    minimum = Math.min(0, minimum)
+    maximum = Math.max(0, maximum)
+  }
+  if (minimum === maximum) {
+    const delta = Math.abs(minimum) * 0.1 || 1
+    if (includeZero && minimum === 0) {
+      maximum = 1
+    } else {
+      minimum -= delta
+      maximum += delta
+    }
+  }
+  const step = niceStep((maximum - minimum) / (tickCount - 1))
+  const niceMinimum = includeZero && minimum >= 0 ? 0 : Math.floor(minimum / step) * step
+  const niceMaximum = includeZero && maximum <= 0 ? 0 : Math.ceil(maximum / step) * step
+  const ticks: number[] = []
+  for (let value = niceMinimum; value <= niceMaximum + step / 2 && ticks.length < 20; value += step) {
+    ticks.push(Object.is(value, -0) ? 0 : value)
+  }
+  return { minimum: niceMinimum, maximum: niceMaximum, ticks }
+}
+
+function linePath(points: readonly Point[], curve: SChartCurve): string {
+  if (points.length === 0) return ''
+  const [first, ...rest] = points
+  let path = `M ${first!.x} ${first!.y}`
+  for (let index = 0; index < rest.length; index += 1) {
+    const previous = points[index]!
+    const current = rest[index]!
+    if (curve === 'linear') {
+      path += ` L ${current.x} ${current.y}`
+      continue
+    }
+    const controlOffset = (current.x - previous.x) / 3
+    path += ` C ${previous.x + controlOffset} ${previous.y}, ${current.x - controlOffset} ${current.y}, ${current.x} ${current.y}`
+  }
+  return path
+}
+
+function polarPoint(centerX: number, centerY: number, radius: number, angle: number): { x: number; y: number } {
+  const radians = (angle - 90) * Math.PI / 180
+  return {
+    x: centerX + radius * Math.cos(radians),
+    y: centerY + radius * Math.sin(radians),
+  }
+}
+
+function radialPath(
+  centerX: number,
+  centerY: number,
+  outerRadius: number,
+  innerRadius: number,
+  startAngle: number,
+  endAngle: number,
+): string {
+  const span = endAngle - startAngle
+  if (span >= 359.999) {
+    const topOuter = polarPoint(centerX, centerY, outerRadius, 0)
+    const bottomOuter = polarPoint(centerX, centerY, outerRadius, 180)
+    if (innerRadius === 0) {
+      return `M ${centerX} ${centerY} L ${topOuter.x} ${topOuter.y} A ${outerRadius} ${outerRadius} 0 1 1 ${bottomOuter.x} ${bottomOuter.y} A ${outerRadius} ${outerRadius} 0 1 1 ${topOuter.x} ${topOuter.y} Z`
+    }
+    const topInner = polarPoint(centerX, centerY, innerRadius, 0)
+    const bottomInner = polarPoint(centerX, centerY, innerRadius, 180)
+    return `M ${topOuter.x} ${topOuter.y} A ${outerRadius} ${outerRadius} 0 1 1 ${bottomOuter.x} ${bottomOuter.y} A ${outerRadius} ${outerRadius} 0 1 1 ${topOuter.x} ${topOuter.y} L ${topInner.x} ${topInner.y} A ${innerRadius} ${innerRadius} 0 1 0 ${bottomInner.x} ${bottomInner.y} A ${innerRadius} ${innerRadius} 0 1 0 ${topInner.x} ${topInner.y} Z`
+  }
+  const outerStart = polarPoint(centerX, centerY, outerRadius, startAngle)
+  const outerEnd = polarPoint(centerX, centerY, outerRadius, endAngle)
+  const largeArc = span > 180 ? 1 : 0
+  if (innerRadius === 0) {
+    return `M ${centerX} ${centerY} L ${outerStart.x} ${outerStart.y} A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${outerEnd.x} ${outerEnd.y} Z`
+  }
+  const innerEnd = polarPoint(centerX, centerY, innerRadius, endAngle)
+  const innerStart = polarPoint(centerX, centerY, innerRadius, startAngle)
+  return `M ${outerStart.x} ${outerStart.y} A ${outerRadius} ${outerRadius} 0 ${largeArc} 1 ${outerEnd.x} ${outerEnd.y} L ${innerEnd.x} ${innerEnd.y} A ${innerRadius} ${innerRadius} 0 ${largeArc} 0 ${innerStart.x} ${innerStart.y} Z`
+}
+
+function resolvePlot(
+  dimensions: ChartDimensions,
+  type: SChartType,
+  size: SChartSize,
+  xAxis: boolean,
+  yAxis: boolean,
+  dataLabels: SChartDataLabels,
+  yTickLabels: readonly string[],
+): PlotRect {
+  if (type === 'pie' || type === 'donut') {
+    const inset = size === 'compact' ? 4 : 12
+    return { x: inset, y: inset, width: dimensions.width - inset * 2, height: dimensions.height - inset * 2 }
+  }
+  const top = dataLabels === 'none'
+    ? (size === 'compact' ? 5 : 12)
+    : (size === 'compact' ? 14 : 24)
+  const right = size === 'compact' ? 6 : 16
+  const bottom = xAxis ? (size === 'compact' ? 32 : 48) : (size === 'compact' ? 5 : 12)
+  const defaultLeft = yAxis ? (size === 'compact' ? 34 : 54) : (size === 'compact' ? 6 : 14)
+  const tickFontSize = size === 'compact' ? 9 : 11
+  const tickWidth = yAxis
+    ? Math.max(0, ...yTickLabels.map((label) => estimateAxisTextWidth(label, tickFontSize)))
+    : 0
+  const desiredLeft = yAxis ? Math.max(defaultLeft, Math.ceil(tickWidth + 16)) : defaultLeft
+  const minimumPlotWidth = Math.min(size === 'compact' ? 72 : 120, dimensions.width * 0.4)
+  const maximumLeft = Math.max(0, dimensions.width - right - minimumPlotWidth)
+  const left = Math.min(desiredLeft, maximumLeft)
+  return {
+    x: left,
+    y: top,
+    width: dimensions.width - left - right,
+    height: dimensions.height - top - bottom,
+  }
+}
+
+function estimateAxisTextWidth(label: string, fontSize: number): number {
+  const units = Array.from(label).reduce((total, character) => {
+    if (/\s/u.test(character)) return total + 0.36
+    if (/[.,:;!|ilI1'`]/u.test(character)) return total + 0.34
+    if (/[MW@%ШЩЖЮ]/u.test(character)) return total + 0.92
+    return total + 0.62
+  }, 0)
+  return units * fontSize
+}
+
+function truncateAxisLabelToWidth(label: string, availableWidth: number, fontSize: number): string {
+  if (estimateAxisTextWidth(label, fontSize) <= availableWidth) return label
+  const ellipsis = '…'
+  const characters = Array.from(label)
+  while (characters.length > 0) {
+    const candidate = `${characters.join('')}${ellipsis}`
+    if (estimateAxisTextWidth(candidate, fontSize) <= availableWidth) return candidate
+    characters.pop()
+  }
+  return ellipsis
+}
+
+function truncateAxisWord(word: string, maximumCharacters: number): string {
+  if (word.length <= maximumCharacters) return word
+  return `${word.slice(0, Math.max(1, maximumCharacters - 1))}…`
+}
+
+function wrapAxisLabel(label: string, availableWidth: number): readonly string[] {
+  const maximumCharacters = Math.max(4, Math.floor((availableWidth - 8) / 6.5))
+  const words = label.trim().split(/\s+/u)
+  const lines: string[] = []
+  let current = ''
+  for (const word of words) {
+    const candidate = current.length === 0 ? word : `${current} ${word}`
+    if (candidate.length <= maximumCharacters) {
+      current = candidate
+      continue
+    }
+    if (current.length > 0) lines.push(current)
+    current = word
+    if (lines.length === 2) break
+  }
+  if (current.length > 0 && lines.length < 2) lines.push(current)
+  const consumedWords = lines.join(' ').split(/\s+/u).length
+  if (consumedWords < words.length && lines.length > 0) {
+    lines[lines.length - 1] = truncateAxisWord(`${lines[lines.length - 1]}…`, maximumCharacters)
+  }
+  return lines.slice(0, 2).map((line) => truncateAxisWord(line, maximumCharacters))
+}
+
+function resolveStackedDomainValues(series: readonly SChartSeries[], categoryCount: number): readonly number[] {
+  const totals: number[] = []
+  for (let categoryIndex = 0; categoryIndex < categoryCount; categoryIndex += 1) {
+    let positive = 0
+    let negative = 0
+    for (const item of series) {
+      const value = item.values[categoryIndex]!
+      if (value >= 0) positive += value
+      else negative += value
+    }
+    totals.push(positive, negative)
+  }
+  return totals
+}
+
+function cartesianModel(
+  input: ResolveChartModelInput,
+  categories: readonly SChartCategory[],
+  series: readonly SChartSeries[],
+  dimensions: ChartDimensions,
+  plot: PlotRect,
+  resolvedDomain: ResolvedDomain,
+  yTickLabels: readonly string[],
+): Omit<ChartModel, 'empty' | 'emptyReason' | 'slices' | 'centerX' | 'centerY'> {
+  const range = resolvedDomain.maximum - resolvedDomain.minimum
+  const yAt = (value: number): number => plot.y + plot.height - ((value - resolvedDomain.minimum) / range) * plot.height
+  const baselineY = Math.max(plot.y, Math.min(plot.y + plot.height, yAt(0)))
+  const categoryBand = plot.width / categories.length
+  const xAt = (index: number): number => plot.x + categoryBand * (index + 0.5)
+  const pointsBySeries = series.map((item, seriesIndex): ChartLineModel => {
+    const tone = resolveTone(item.tone, seriesIndex)
+    const points = item.values.map((value, categoryIndex): Point => {
+      const category = categories[categoryIndex]!
+      const valueLabel = formatValue(input.valueFormatter, value, `${item.key}.${category.key}`)
+      return {
+        x: xAt(categoryIndex),
+        y: yAt(value),
+        value,
+        valueLabel,
+        categoryKey: category.key,
+        categoryLabel: category.label,
+        seriesKey: item.key,
+        seriesLabel: item.label,
+        tone,
+        title: `${item.label}, ${category.label}: ${valueLabel}`,
+      }
+    })
+    const path = linePath(points, input.curve)
+    const areaPath = points.length === 0
+      ? ''
+      : `${path} L ${points[points.length - 1]!.x} ${baselineY} L ${points[0]!.x} ${baselineY} Z`
+    return { key: item.key, label: item.label, tone, path, areaPath, points }
+  })
+
+  const bars: ChartBarModel[] = []
+  if (input.type === 'bar') {
+    const groupWidth = categoryBand * 0.72
+    const positiveTotals = Array.from({ length: categories.length }, () => 0)
+    const negativeTotals = Array.from({ length: categories.length }, () => 0)
+    for (let seriesIndex = 0; seriesIndex < series.length; seriesIndex += 1) {
+      const item = series[seriesIndex]!
+      const tone = resolveTone(item.tone, seriesIndex)
+      for (let categoryIndex = 0; categoryIndex < categories.length; categoryIndex += 1) {
+        const category = categories[categoryIndex]!
+        const value = item.values[categoryIndex]!
+        let startValue = 0
+        let endValue = value
+        let x = xAt(categoryIndex) - groupWidth / 2 + seriesIndex * (groupWidth / series.length)
+        let width = groupWidth / series.length
+        if (input.barMode === 'stacked') {
+          startValue = value >= 0 ? positiveTotals[categoryIndex]! : negativeTotals[categoryIndex]!
+          endValue = startValue + value
+          if (value >= 0) positiveTotals[categoryIndex] = endValue
+          else negativeTotals[categoryIndex] = endValue
+          x = xAt(categoryIndex) - groupWidth * 0.34
+          width = groupWidth * 0.68
+        }
+        const yStart = yAt(startValue)
+        const yEnd = yAt(endValue)
+        const valueLabel = formatValue(input.valueFormatter, value, `${item.key}.${category.key}`)
+        bars.push({
+          key: `${item.key}:${category.key}`,
+          x,
+          y: Math.min(yStart, yEnd),
+          width,
+          height: Math.max(1, Math.abs(yEnd - yStart)),
+          value,
+          valueLabel,
+          categoryKey: category.key,
+          categoryLabel: category.label,
+          seriesKey: item.key,
+          seriesLabel: item.label,
+          tone,
+          title: `${item.label}, ${category.label}: ${valueLabel}`,
+        })
+      }
+    }
+  }
+
+  const showXLabel = (index: number): boolean => {
+    if (input.xLabels === 'none') return false
+    if (input.xLabels === 'all') return true
+    if (input.xLabels === 'endpoints') return index === 0 || index === categories.length - 1
+    return categories.length <= 6 || index === 0 || index === categories.length - 1
+  }
+  const visibleCategories = categories
+    .map((category, index) => ({ category, index, x: xAt(index) }))
+    .filter(({ index }) => showXLabel(index))
+  const xLabels = visibleCategories.map(({ category, x }, visibleIndex): ChartCategoryLabel => {
+    const previous = visibleCategories[visibleIndex - 1]
+    const next = visibleCategories[visibleIndex + 1]
+    if (visibleCategories.length === 1) {
+      return {
+        key: category.key,
+        label: category.label,
+        lines: wrapAxisLabel(category.label, plot.width),
+        x: plot.x + plot.width / 2,
+        textAnchor: 'middle',
+      }
+    }
+    if (!previous) {
+      const rightBoundary = (x + next!.x) / 2
+      return {
+        key: category.key,
+        label: category.label,
+        lines: wrapAxisLabel(category.label, rightBoundary - plot.x),
+        x: plot.x,
+        textAnchor: 'start',
+      }
+    }
+    if (!next) {
+      const leftBoundary = (previous.x + x) / 2
+      return {
+        key: category.key,
+        label: category.label,
+        lines: wrapAxisLabel(category.label, plot.x + plot.width - leftBoundary),
+        x: plot.x + plot.width,
+        textAnchor: 'end',
+      }
+    }
+    const leftBoundary = (previous.x + x) / 2
+    const rightBoundary = (x + next.x) / 2
+    return {
+      key: category.key,
+      label: category.label,
+      lines: wrapAxisLabel(category.label, 2 * Math.min(x - leftBoundary, rightBoundary - x)),
+      x,
+      textAnchor: 'middle',
+    }
+  })
+  const tickFontSize = input.size === 'compact' ? 9 : 11
+  const tickLabelWidth = Math.max(1, plot.x - 16)
+  const yTicks = resolvedDomain.ticks.map((value, index) => ({
+    value,
+    label: yTickLabels[index]!,
+    displayLabel: truncateAxisLabelToWidth(yTickLabels[index]!, tickLabelWidth, tickFontSize),
+    position: yAt(value),
+  }))
+  const horizontalGrid = yTicks.map((tick) => ({
+    key: `y:${tick.value}`,
+    x1: plot.x,
+    x2: plot.x + plot.width,
+    y1: tick.position,
+    y2: tick.position,
+  }))
+  const verticalGrid = categories.map((category, index) => ({
+    key: `x:${category.key}`,
+    x1: xAt(index),
+    x2: xAt(index),
+    y1: plot.y,
+    y2: plot.y + plot.height,
+  }))
+  return {
+    width: dimensions.width,
+    height: dimensions.height,
+    plotX: plot.x,
+    plotY: plot.y,
+    plotWidth: plot.width,
+    plotHeight: plot.height,
+    baselineY,
+    lines: pointsBySeries,
+    bars,
+    horizontalGrid,
+    verticalGrid,
+    yTicks,
+    xLabels,
+    legend: series.map((item, index) => ({
+      key: item.key,
+      label: item.label,
+      tone: resolveTone(item.tone, index),
+    })),
+    tableRows: categories.map((category, categoryIndex) => ({
+      key: category.key,
+      label: category.label,
+      values: series.map((item) => formatValue(
+        input.valueFormatter,
+        item.values[categoryIndex]!,
+        `${item.key}.${category.key}`,
+      )),
+    })),
+  }
+}
+
+function radialModel(
+  input: ResolveChartModelInput,
+  categories: readonly SChartCategory[],
+  series: readonly SChartSeries[],
+  dimensions: ChartDimensions,
+  plot: PlotRect,
+): ChartModel {
+  if (series.length !== 1) fail(`${input.type} требует ровно одну series`)
+  if (input.xAxis || input.yAxis) fail(`${input.type} не поддерживает Cartesian axes`)
+  if (input.markers !== 'none') fail(`${input.type} не поддерживает markers`)
+  if (input.dataLabels === 'latest') fail(`${input.type} поддерживает dataLabels только none или all`)
+  const item = series[0]!
+  for (let index = 0; index < item.values.length; index += 1) {
+    if (item.values[index]! < 0) fail(`${input.type} не допускает отрицательное series[0].values[${index}]`)
+  }
+  const total = item.values.reduce((sum, value) => sum + value, 0)
+  const centerX = plot.x + plot.width / 2
+  const centerY = plot.y + plot.height / 2
+  const outerRadius = Math.max(1, Math.min(plot.width, plot.height) / 2)
+  const innerRadius = input.type === 'donut' ? outerRadius * 0.58 : 0
+  let angle = 0
+  const slices = total === 0 ? [] : categories.map((category, index): ChartSliceModel => {
+    const value = item.values[index]!
+    const startAngle = angle
+    const endAngle = angle + value / total * 360
+    angle = endAngle
+    const midAngle = startAngle + (endAngle - startAngle) / 2
+    const labelRadius = innerRadius + (outerRadius - innerRadius) * 0.58
+    const labelPoint = polarPoint(centerX, centerY, labelRadius, midAngle)
+    const valueLabel = formatValue(input.valueFormatter, value, `${item.key}.${category.key}`)
+    const percentageLabel = `${new Intl.NumberFormat(undefined, { maximumFractionDigits: 1 }).format(value / total * 100)}%`
+    const dataLabel = input.radialLabel === 'category'
+      ? category.label
+      : input.radialLabel === 'percentage'
+        ? percentageLabel
+        : valueLabel
+    return {
+      key: category.key,
+      label: category.label,
+      tone: resolveTone(category.tone, index),
+      value,
+      valueLabel,
+      percentageLabel,
+      path: radialPath(centerX, centerY, outerRadius, innerRadius, startAngle, endAngle),
+      labelX: labelPoint.x,
+      labelY: labelPoint.y,
+      dataLabel,
+      title: `${category.label}: ${valueLabel} (${percentageLabel})`,
+    }
+  })
+  return {
+    width: dimensions.width,
+    height: dimensions.height,
+    plotX: plot.x,
+    plotY: plot.y,
+    plotWidth: plot.width,
+    plotHeight: plot.height,
+    baselineY: centerY,
+    empty: total === 0,
+    emptyReason: total === 0 ? 'zero-total' : null,
+    lines: [],
+    bars: [],
+    slices,
+    horizontalGrid: [],
+    verticalGrid: [],
+    yTicks: [],
+    xLabels: [],
+    legend: categories.map((category, index) => ({
+      key: category.key,
+      label: category.label,
+      tone: resolveTone(category.tone, index),
+    })),
+    tableRows: categories.map((category, index) => ({
+      key: category.key,
+      label: category.label,
+      values: [formatValue(input.valueFormatter, item.values[index]!, `${item.key}.${category.key}`)],
+    })),
+    centerX,
+    centerY,
+  }
+}
+
+/** Валидирует public data contract и строит детерминированную SVG-модель. / Validates the public data contract and builds deterministic SVG geometry. */
+export function resolveChartModel(input: ResolveChartModelInput): ChartModel {
+  const categories = validateCategories(input.categories)
+  const series = validateSeries(input.series, categories.length)
+  if (!SIZE_DIMENSIONS[input.size]) fail(`неизвестный size ${JSON.stringify(input.size)}`)
+  const dimensions = resolveDimensions(input.size, input.dimensions)
+  if (categories.length === 0 || series.length === 0) {
+    if (categories.length !== 0 || series.length !== 0) {
+      fail('empty state требует одновременно пустые categories и series')
+    }
+    return {
+      width: dimensions.width,
+      height: dimensions.height,
+      plotX: 0,
+      plotY: 0,
+      plotWidth: dimensions.width,
+      plotHeight: dimensions.height,
+      baselineY: dimensions.height,
+      empty: true,
+      emptyReason: 'no-data',
+      lines: [],
+      bars: [],
+      slices: [],
+      horizontalGrid: [],
+      verticalGrid: [],
+      yTicks: [],
+      xLabels: [],
+      legend: [],
+      tableRows: [],
+      centerX: dimensions.width / 2,
+      centerY: dimensions.height / 2,
+    }
+  }
+  if (input.type === 'pie' || input.type === 'donut') {
+    const plot = resolvePlot(
+      dimensions,
+      input.type,
+      input.size,
+      input.xAxis,
+      input.yAxis,
+      input.dataLabels,
+      [],
+    )
+    return radialModel(input, categories, series, dimensions, plot)
+  }
+  const domainValues = input.type === 'bar' && input.barMode === 'stacked'
+    ? resolveStackedDomainValues(series, categories.length)
+    : series.flatMap((item) => [...item.values])
+  const resolvedDomain = resolveDomain(
+    input.domain,
+    domainValues,
+    input.type === 'bar' || input.type === 'area',
+    input.yTickCount,
+  )
+  const yTickLabels = resolvedDomain.ticks.map((value) => formatValue(
+    input.valueFormatter,
+    value,
+    `yTick.${value}`,
+  ))
+  const plot = resolvePlot(
+    dimensions,
+    input.type,
+    input.size,
+    input.xAxis,
+    input.yAxis,
+    input.dataLabels,
+    yTickLabels,
+  )
+  const model = cartesianModel(
+    input,
+    categories,
+    series,
+    dimensions,
+    plot,
+    resolvedDomain,
+    yTickLabels,
+  )
+  return {
+    ...model,
+    empty: false,
+    emptyReason: null,
+    slices: [],
+    centerX: plot.x + plot.width / 2,
+    centerY: plot.y + plot.height / 2,
+  }
+}