@pgcorp/ui-kit 0.10.0 → 0.10.2

package/src/internal/chartGeometry.ts

@@ -1,852 +0,0 @@
-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,
-  }
-}