@veltra/sheet 2.3.4 → 2.5.0

package/src/report/render/aggregate.ts

@@ -1,261 +0,0 @@
-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 isReductionAggregate(aggregate: ReportAggregate): boolean {
-  return (
-    aggregate === 'sum' ||
-    aggregate === 'avg' ||
-    aggregate === 'count' ||
-    aggregate === 'max' ||
-    aggregate === 'min'
-  )
-}
-
-function rowExpandingAncestors(
-  binding: ReportBinding,
-  index: TemplateIndex,
-  groupsOnly: boolean
-): 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) => {
-    if (!isRowExpanding(item.binding)) return false
-    if (groupsOnly && item.binding.aggregate !== 'group') return false
-    return true
-  })
-}
-
-function colExpandingAncestors(
-  binding: ReportBinding,
-  index: TemplateIndex,
-  groupsOnly: boolean
-): 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) => {
-    if (!isColExpanding(item.binding)) return false
-    if (groupsOnly && item.binding.aggregate !== 'group') return false
-    return true
-  })
-}
-
-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 groupsOnly = isReductionAggregate(binding.aggregate)
-
-  const rowAncestors = rowExpandingAncestors(binding, index, groupsOnly)
-  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, groupsOnly)
-  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, false)
-  const colAncestors = colExpandingAncestors(binding, index, false)
-  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

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