@veltra/sheet 2.1.1 → 2.2.0

package/src/report/render/aggregate.ts

@@ -0,0 +1,240 @@
+import type { CellAddress } from '@veltra/sheet-core'
+
+import type { DatasetRecords, ReportAggregate, ReportBinding } from '../types'
+import { enumerateExpansionInstances } from './coordinate'
+import type { PhysicalPlacement } from './coordinate'
+import type { TemplateIndex } from './template-index'
+
+function filterRows(
+  rows: Record<string, unknown>[],
+  filter: Record<string, unknown>
+): Record<string, unknown>[] {
+  if (Object.keys(filter).length === 0) return rows
+  return rows.filter((row) =>
+    Object.entries(filter).every(([field, value]) => row[field] === value)
+  )
+}
+
+/** 对数值集求聚合；`avg` 空集返回 `undefined`，`sum` 空集仍为 `0` */
+export function aggregateField(
+  rows: Record<string, unknown>[],
+  field: string,
+  aggregate: ReportAggregate
+): unknown {
+  if (aggregate === 'count') return rows.length
+  if (aggregate === 'list' || aggregate === 'group') {
+    return rows[0]?.[field]
+  }
+
+  const numbers = rows
+    .map((row) => row[field])
+    .map((value) => (typeof value === 'number' ? value : Number(value)))
+    .filter((value) => Number.isFinite(value))
+
+  if (numbers.length === 0) {
+    if (aggregate === 'avg') return undefined
+    return 0
+  }
+
+  const sum = numbers.reduce((acc, value) => acc + value, 0)
+  if (aggregate === 'avg') return sum / numbers.length
+  if (aggregate === 'max') return Math.max(...numbers)
+  if (aggregate === 'min') return Math.min(...numbers)
+  return sum
+}
+
+function isRowExpanding(binding: ReportBinding): boolean {
+  return (
+    binding.expand === 'down' && (binding.aggregate === 'group' || binding.aggregate === 'list')
+  )
+}
+
+function isColExpanding(binding: ReportBinding): boolean {
+  return (
+    binding.expand === 'right' && (binding.aggregate === 'group' || binding.aggregate === 'list')
+  )
+}
+
+function rowExpandingAncestors(
+  binding: ReportBinding,
+  index: TemplateIndex
+): Array<{ addr: CellAddress; binding: ReportBinding }> {
+  const chain: Array<{ addr: CellAddress; binding: ReportBinding }> = []
+  let current = binding.rowParent
+  while (current) {
+    const parentBinding = index.bindingAt(current)
+    if (parentBinding) chain.unshift({ addr: current, binding: parentBinding })
+    current = parentBinding?.rowParent
+  }
+  return chain.filter((item) => isRowExpanding(item.binding))
+}
+
+function colExpandingAncestors(
+  binding: ReportBinding,
+  index: TemplateIndex
+): Array<{ addr: CellAddress; binding: ReportBinding }> {
+  const chain: Array<{ addr: CellAddress; binding: ReportBinding }> = []
+  let current = binding.colParent
+  while (current) {
+    const parentBinding = index.bindingAt(current)
+    if (parentBinding) chain.unshift({ addr: current, binding: parentBinding })
+    current = parentBinding?.colParent
+  }
+  return chain.filter((item) => isColExpanding(item.binding))
+}
+
+function mergeFilters(
+  rowFilter: Record<string, unknown>,
+  colFilter: Record<string, unknown>
+): Record<string, unknown> {
+  return { ...rowFilter, ...colFilter }
+}
+
+function resolveAncestorFilters(
+  binding: ReportBinding,
+  placement: PhysicalPlacement,
+  index: TemplateIndex,
+  data: DatasetRecords
+): Record<string, unknown> {
+  const rowFilter: Record<string, unknown> = {}
+  const colFilter: Record<string, unknown> = {}
+  let parentFilter: Record<string, unknown> = {}
+
+  const rowAncestors = rowExpandingAncestors(binding, index)
+  for (let i = 0; i < rowAncestors.length; i++) {
+    const ancestor = rowAncestors[i]!
+    if (ancestor.binding.dataset !== binding.dataset) continue
+    const instances = enumerateExpansionInstances(ancestor.binding, data, parentFilter)
+    const pathIndex = placement.rowPath[i]
+    if (pathIndex === undefined) continue
+    const instance = instances[pathIndex]
+    if (!instance) continue
+    Object.assign(rowFilter, instance.filter)
+    parentFilter = instance.filter
+  }
+
+  parentFilter = {}
+  const colAncestors = colExpandingAncestors(binding, index)
+  for (let i = 0; i < colAncestors.length; i++) {
+    const ancestor = colAncestors[i]!
+    if (ancestor.binding.dataset !== binding.dataset) continue
+    const instances = enumerateExpansionInstances(ancestor.binding, data, parentFilter)
+    const pathIndex = placement.colPath[i]
+    if (pathIndex === undefined) continue
+    const instance = instances[pathIndex]
+    if (!instance) continue
+    Object.assign(colFilter, instance.filter)
+    parentFilter = instance.filter
+  }
+
+  return mergeFilters(rowFilter, colFilter)
+}
+
+function resolveOwnGroupValue(
+  binding: ReportBinding,
+  placement: PhysicalPlacement,
+  index: TemplateIndex,
+  data: DatasetRecords
+): unknown {
+  const rowAncestors = rowExpandingAncestors(binding, index)
+  const colAncestors = colExpandingAncestors(binding, index)
+  let parentFilter: Record<string, unknown> = {}
+
+  for (let i = 0; i < rowAncestors.length; i++) {
+    const ancestor = rowAncestors[i]!
+    if (ancestor.binding.dataset !== binding.dataset) continue
+    const instances = enumerateExpansionInstances(ancestor.binding, data, parentFilter)
+    const pathIndex = placement.rowPath[i]
+    if (pathIndex === undefined) continue
+    const instance = instances[pathIndex]
+    if (instance) parentFilter = instance.filter
+  }
+
+  for (let i = 0; i < colAncestors.length; i++) {
+    const ancestor = colAncestors[i]!
+    if (ancestor.binding.dataset !== binding.dataset) continue
+    const instances = enumerateExpansionInstances(ancestor.binding, data, parentFilter)
+    const pathIndex = placement.colPath[i]
+    if (pathIndex === undefined) continue
+    const instance = instances[pathIndex]
+    if (instance) parentFilter = instance.filter
+  }
+
+  const instances = enumerateExpansionInstances(binding, data, parentFilter)
+  const pathIndex = isRowExpanding(binding) ? placement.rowPath.at(-1) : placement.colPath.at(-1)
+  if (pathIndex === undefined) return undefined
+  return instances[pathIndex]?.value
+}
+
+/** 按分组字段建索引，避免交叉展开重复 filterRows */
+export class AggregateIndex {
+  private readonly datasets = new Map<string, Record<string, unknown>[]>()
+  private readonly filterCache = new Map<string, Record<string, unknown>[]>()
+
+  constructor(data: DatasetRecords) {
+    for (const [datasetId, rows] of Object.entries(data)) {
+      this.datasets.set(datasetId, rows)
+    }
+  }
+
+  rowsFor(dataset: string, filter: Record<string, unknown>): Record<string, unknown>[] {
+    const cacheKey = `${dataset}:${JSON.stringify(filter)}`
+    const cached = this.filterCache.get(cacheKey)
+    if (cached) return cached
+    const rows = filterRows(this.datasets.get(dataset) ?? [], filter)
+    this.filterCache.set(cacheKey, rows)
+    return rows
+  }
+
+  aggregate(
+    dataset: string,
+    filter: Record<string, unknown>,
+    field: string,
+    aggregate: ReportAggregate
+  ): unknown {
+    const rows = this.rowsFor(dataset, filter)
+    if (aggregate === 'list') {
+      return rows[0]?.[field]
+    }
+    return aggregateField(rows, field, aggregate)
+  }
+}
+
+/** 解析单个物理落点的绑定取值 */
+export function resolvePlacementValue(
+  placement: PhysicalPlacement,
+  index: TemplateIndex,
+  data: DatasetRecords,
+  aggregateIndex: AggregateIndex
+): unknown {
+  const binding = placement.binding
+  if (!binding) return undefined
+
+  const filter = resolveAncestorFilters(binding, placement, index, data)
+  const rows = aggregateIndex.rowsFor(binding.dataset, filter)
+
+  if (binding.aggregate === 'group') {
+    return filter[binding.field] ?? resolveOwnGroupValue(binding, placement, index, data)
+  }
+
+  if (binding.aggregate === 'list') {
+    return rows[placement.listIndex]?.[binding.field]
+  }
+
+  return aggregateField(rows, binding.field, binding.aggregate)
+}
+
+/** 解析 `list` 明细落点对应的源数据行；非 list 绑定无单条记录上下文 */
+export function resolvePlacementRecord(
+  placement: PhysicalPlacement,
+  index: TemplateIndex,
+  data: DatasetRecords,
+  aggregateIndex: AggregateIndex
+): Record<string, unknown> | undefined {
+  const binding = placement.binding
+  if (!binding || binding.aggregate !== 'list') return undefined
+
+  const filter = resolveAncestorFilters(binding, placement, index, data)
+  const rows = aggregateIndex.rowsFor(binding.dataset, filter)
+  return rows[placement.listIndex]
+}

package/src/report/render/builder.ts

@@ -0,0 +1,211 @@
+import type {
+  CellRange,
+  CellSnapshotItem,
+  CellType,
+  CellValue,
+  SheetSnapshot
+} from '@veltra/sheet-core'
+import { cellKey } from '@veltra/sheet-core'
+
+import type { ReportColWidthEntry } from '../export-xlsx'
+import type { ConditionalEvalContext } from '../rules'
+import type { DatasetRecords } from '../types'
+import { AggregateIndex, resolvePlacementRecord, resolvePlacementValue } from './aggregate'
+import type { ExpansionLayout, PhysicalPlacement } from './coordinate'
+import { physicalColSpan, physicalRowSpan } from './coordinate'
+import { StyleResolver } from './style-resolver'
+import type { TemplateIndex } from './template-index'
+
+function toCellValue(value: unknown): { v: CellValue; t?: CellType } {
+  if (value === null || value === undefined) return { v: '' }
+  if (typeof value === 'number' && !Number.isNaN(value)) return { v: value, t: 'n' }
+  if (typeof value === 'boolean') return { v: value, t: 'b' }
+  if (typeof value === 'string') return { v: value, t: 's' }
+  if (value instanceof Date) return { v: value.toISOString().slice(0, 10), t: 's' }
+  return { v: JSON.stringify(value), t: 's' }
+}
+
+function rangeCells(range: CellRange): Array<{ row: number; col: number }> {
+  const cells: Array<{ row: number; col: number }> = []
+  for (let row = range.start.row; row <= range.end.row; row++) {
+    for (let col = range.start.col; col <= range.end.col; col++) {
+      cells.push({ row, col })
+    }
+  }
+  return cells
+}
+
+function placementSourceValue(
+  placement: PhysicalPlacement,
+  template: SheetSnapshot,
+  index: TemplateIndex,
+  data: DatasetRecords,
+  aggregateIndex: AggregateIndex
+): unknown {
+  if (placement.binding) {
+    return resolvePlacementValue(placement, index, data, aggregateIndex)
+  }
+  const staticCell = index.cellAt(placement.logical)
+  return staticCell?.v
+}
+
+function colWidthSourceLogicalCol(placement: PhysicalPlacement): number {
+  const binding = placement.binding
+  if (binding?.colParent) {
+    return binding.colParent.col
+  }
+  return placement.logical.col
+}
+
+/**
+ * 将模板列宽映射到填充报表物理列：横向展开列继承列方向父格所在模板列宽。
+ */
+export function mapFilledColWidths(
+  templateColWidths: ReadonlyArray<ReportColWidthEntry>,
+  layout: ExpansionLayout,
+  _index: TemplateIndex
+): ReportColWidthEntry[] {
+  if (templateColWidths.length === 0 || layout.colCount === 0) return []
+
+  const widthByTemplateCol = new Map<number, number>()
+  for (const [col, width] of templateColWidths) {
+    widthByTemplateCol.set(col, width)
+  }
+
+  const physicalWidths = new Map<number, number>()
+  for (const placement of layout.placements) {
+    const sourceCol = colWidthSourceLogicalCol(placement)
+    const width = widthByTemplateCol.get(sourceCol)
+    if (width === undefined) continue
+
+    const startCol = placement.physical.start.col
+    const endCol = placement.physical.end.col
+    for (let col = startCol; col <= endCol; col++) {
+      physicalWidths.set(col, width)
+    }
+  }
+
+  return [...physicalWidths.entries()].sort((a, b) => a[0] - b[0])
+}
+
+function placementEvalContext(
+  placement: PhysicalPlacement,
+  value: unknown,
+  template: SheetSnapshot,
+  index: TemplateIndex,
+  data: DatasetRecords,
+  aggregateIndex: AggregateIndex
+): ConditionalEvalContext {
+  const binding = placement.binding
+  return {
+    cellValue: value,
+    bindingField: binding?.field ?? '',
+    record: binding ? resolvePlacementRecord(placement, index, data, aggregateIndex) : undefined
+  }
+}
+
+function collectRowConditionalStyles(
+  layout: ExpansionLayout,
+  template: SheetSnapshot,
+  index: TemplateIndex,
+  data: DatasetRecords,
+  styles: StyleResolver
+): void {
+  const aggregateIndex = new AggregateIndex(data)
+
+  for (const placement of layout.placements) {
+    const binding = placement.binding
+    if (!binding?.conditionalRules?.some((rule) => rule.scope === 'row')) continue
+
+    const value = placementSourceValue(placement, template, index, data, aggregateIndex)
+    const ctx = placementEvalContext(placement, value, template, index, data, aggregateIndex)
+
+    for (let row = placement.physical.start.row; row <= placement.physical.end.row; row++) {
+      styles.collectRowStyle(row, ctx, binding.conditionalRules)
+    }
+  }
+}
+
+/** 由扩展坐标布局组装 Filled Report 快照 */
+export function buildFilledReport(
+  template: SheetSnapshot,
+  index: TemplateIndex,
+  layout: ExpansionLayout,
+  data: DatasetRecords
+): SheetSnapshot {
+  const styles = new StyleResolver(template)
+  collectRowConditionalStyles(layout, template, index, data, styles)
+
+  const aggregateIndex = new AggregateIndex(data)
+  const cells: CellSnapshotItem[] = []
+  const merges: CellRange[] = [...layout.mappedMerges]
+  const mergeKeys = new Set(merges.map((m) => cellKey(m.start)))
+
+  const pushMerge = (range: CellRange): void => {
+    const key = cellKey(range.start)
+    if (mergeKeys.has(key)) return
+    mergeKeys.add(key)
+    merges.push(range)
+  }
+
+  const resolveStyleId = (
+    placement: PhysicalPlacement,
+    templateRow: number,
+    templateCol: number,
+    value: unknown,
+    physicalRow: number
+  ): number | undefined => {
+    const binding = placement.binding
+    const ctx = placementEvalContext(placement, value, template, index, data, aggregateIndex)
+    const baseStyleId = binding
+      ? styles.resolveCell(templateRow, templateCol, ctx, binding.conditionalRules)
+      : styles.resolveStatic(templateRow, templateCol)
+    return styles.mergeRowStyle(baseStyleId, physicalRow)
+  }
+
+  for (const placement of layout.placements) {
+    const value = placementSourceValue(placement, template, index, data, aggregateIndex)
+    const { row: templateRow, col: templateCol } = placement.logical
+
+    const rowSpan = physicalRowSpan(placement)
+    const colSpan = physicalColSpan(placement)
+    const shouldMerge = placement.mergeSpan && (rowSpan > 1 || colSpan > 1)
+
+    if (shouldMerge) {
+      const item: CellSnapshotItem = {
+        row: placement.physical.start.row,
+        col: placement.physical.start.col,
+        ...toCellValue(value)
+      }
+      const styleId = resolveStyleId(
+        placement,
+        templateRow,
+        templateCol,
+        value,
+        placement.physical.start.row
+      )
+      if (styleId !== undefined) item.s = styleId
+      cells.push(item)
+      if (rowSpan > 1 || colSpan > 1) {
+        pushMerge(placement.physical)
+      }
+      continue
+    }
+
+    for (const pos of rangeCells(placement.physical)) {
+      const item: CellSnapshotItem = { row: pos.row, col: pos.col, ...toCellValue(value) }
+      const styleId = resolveStyleId(placement, templateRow, templateCol, value, pos.row)
+      if (styleId !== undefined) item.s = styleId
+      cells.push(item)
+    }
+  }
+
+  return {
+    cells,
+    styles: styles.snapshot(),
+    merges,
+    frozen: template.frozen,
+    rows: layout.rowCount,
+    cols: Math.max(layout.colCount, template.cols)
+  }
+}