@report-designer/core 0.1.0

package/dist/layout-engine/layout-band.js

@@ -0,0 +1,1243 @@
+import { evalExpression } from '../expression-engine/evaluator';
+import { AggregateRuntime } from '../aggregate-engine';
+import { createEventContext, runEventScript } from '../event-engine';
+import { applyConditionalFormatsToStyle } from '../conditional-format';
+import { isRepeatOnEveryPageBandType } from '../template-model/types';
+import { getChartCapabilities } from '../chart';
+import { formatValue } from '../text-format';
+import { resolveComponentStyle, resolveTextStyle } from '../text-style';
+import { measureTextBox } from './measure';
+export function createLayoutEventState() {
+    return {
+        componentExecutions: new WeakMap(),
+        componentAfterPrint: new WeakSet(),
+    };
+}
+export function layoutBand(band, options) {
+    const behavior = band.behavior ?? {
+        enabled: true,
+        printOn: 'allPages',
+        printIfEmpty: true,
+        printOnAllPages: isRepeatOnEveryPageBandType(band.type),
+        keepTogether: false,
+        canBreak: band.type === 'data',
+        printAtBottom: band.type === 'pageFooter',
+        autoGrow: true,
+        autoShrink: false,
+    };
+    const hierarchyIndentComponentId = findHierarchyIndentComponentId(band);
+    const hierarchyIndent = typeof options.context.row?.HierarchyIndent === 'string'
+        ? options.context.row.HierarchyIndent
+        : '';
+    const components = band.components
+        .map((component) => {
+        const rendered = layoutComponentWithEvents(component, band, options);
+        return applyHierarchyIndent(rendered, component, hierarchyIndentComponentId, hierarchyIndent);
+    })
+        .filter((component) => Boolean(component));
+    const contentHeight = components.reduce((height, component) => Math.max(height, component.y - options.y + component.height), 0);
+    const fixedHeight = Math.max(0, band.height);
+    const resolvedHeight = behavior.autoGrow === false
+        ? fixedHeight
+        : Math.max(fixedHeight, contentHeight);
+    const finalHeight = behavior.autoShrink && contentHeight < resolvedHeight ? contentHeight : resolvedHeight;
+    return {
+        id: `${band.id}-${options.x}-${options.y}`,
+        bandId: band.id,
+        bandType: band.type,
+        x: options.x,
+        y: options.y,
+        width: options.width,
+        height: finalHeight,
+        backgroundColor: resolveDataBandRowBackground(band, options.context.rowIndex, Boolean(options.context.row)),
+        components,
+        overflow: components.some((component) => component.overflow) || (behavior.autoGrow === false && contentHeight > fixedHeight),
+    };
+}
+function findHierarchyIndentComponentId(band) {
+    if (band.type !== 'hierarchicalData') {
+        return undefined;
+    }
+    return band.components
+        .filter((component) => component.type === 'text')
+        .sort((a, b) => a.x - b.x || a.y - b.y)[0]?.id;
+}
+function applyHierarchyIndent(rendered, source, indentComponentId, indent) {
+    if (!rendered || !indent || source.id !== indentComponentId || !isRenderText(rendered)) {
+        return rendered;
+    }
+    const sourceText = source.type === 'text' ? source.text : '';
+    if (sourceText.includes('HierarchyIndent')) {
+        return rendered;
+    }
+    return {
+        ...rendered,
+        content: `${indent}${rendered.content ?? ''}`,
+    };
+}
+function isRenderText(component) {
+    return component.type === 'text' && 'content' in component;
+}
+function resolveDataBandRowBackground(band, rowIndex, hasRow) {
+    if (!hasRow || (band.type !== 'data' && band.type !== 'hierarchicalData')) {
+        return undefined;
+    }
+    return rowIndex % 2 === 0
+        ? band.dataBand?.oddRowBackgroundColor
+        : band.dataBand?.evenRowBackgroundColor;
+}
+function layoutComponentWithEvents(component, band, options) {
+    if (!isComponentRenderable(component, options)) {
+        return undefined;
+    }
+    if (!options.eventRuntime) {
+        return layoutComponent(component, band, options);
+    }
+    const cachedExecution = options.eventState?.componentExecutions.get(component);
+    const execution = cachedExecution ?? { canceled: false, hidden: false, hasValue: false };
+    if (!cachedExecution) {
+        runComponentEvent(component, band, options, 'getValue', execution);
+        runComponentEvent(component, band, options, 'beforePrint', execution);
+        options.eventState?.componentExecutions.set(component, execution);
+    }
+    if (execution.hidden || execution.canceled) {
+        return undefined;
+    }
+    const box = layoutComponent(component, band, options, execution);
+    if (options.eventMode !== 'measure' && !options.eventState?.componentAfterPrint.has(component)) {
+        runComponentEvent(component, band, options, 'afterPrint', execution);
+        options.eventState?.componentAfterPrint.add(component);
+    }
+    return box;
+}
+function runComponentEvent(component, band, options, eventName, execution) {
+    const eventRuntime = options.eventRuntime;
+    const event = component.events?.[eventName];
+    if (!eventRuntime || !event)
+        return;
+    const target = { ownerType: 'component', ownerId: component.id, eventName };
+    const ctx = createEventContext({
+        mode: eventRuntime.mode,
+        report: eventRuntime.report,
+        page: eventRuntime.page,
+        band,
+        component,
+        row: options.context.row,
+        rowIndex: options.context.rowIndex,
+        dataSourceId: options.context.dataSourceId,
+        data: eventRuntime.data,
+        parameters: options.context.parameters ?? eventRuntime.parameters,
+        variables: eventRuntime.variables,
+        state: eventRuntime.state,
+        log: eventRuntime.log,
+        target,
+        runtime: eventRuntime.runtime,
+        execution,
+    });
+    runEventScript({
+        event,
+        ctx,
+        target,
+        eventLogs: eventRuntime.log,
+        runtimeState: eventRuntime.runtime,
+    });
+}
+function isComponentRenderable(component, options) {
+    if (!resolveOptionalBoolean(component.enabledExpression, options))
+        return false;
+    if (!resolveOptionalBoolean(component.visible, options))
+        return false;
+    if (!resolveOptionalBoolean(component.printableExpression, options))
+        return false;
+    return true;
+}
+function resolveOptionalBoolean(value, options) {
+    if (!value || value.trim() === '')
+        return true;
+    return resolveTemplateBoolean(value, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {});
+}
+function layoutComponent(component, band, options, execution) {
+    if (component.type === 'text') {
+        const textComponent = component;
+        const effective = resolveTextComponentStyle(textComponent, options.styles ?? []);
+        const style = applyTextConditionalFormats(effective, component, options);
+        if (style.enabled === false) {
+            return undefined;
+        }
+        const text = resolveText(effective, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}, execution);
+        const measured = measureTextBox({ ...effective, ...style, backgroundColor: style.background }, text);
+        return {
+            id: component.id,
+            type: 'text',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: measured.height,
+            content: text,
+            overflow: measured.overflow,
+            style: {
+                font: style.font ?? effective.font,
+                border: style.border ?? effective.border,
+                backgroundColor: style.background ?? effective.backgroundColor,
+                textAlign: style.textAlign ?? effective.textAlign,
+                verticalAlign: style.verticalAlign ?? effective.verticalAlign,
+                padding: style.padding ?? effective.padding,
+                format: style.format ?? effective.format,
+                canGrow: style.canGrow ?? effective.canGrow,
+                canShrink: style.canShrink ?? effective.canShrink,
+            },
+        };
+    }
+    if (component.type === 'image') {
+        const imageComponent = component;
+        return {
+            id: component.id,
+            type: 'image',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            src: resolveTemplateValue(imageComponent.src, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}),
+            fitMode: imageComponent.fitMode,
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    if (component.type === 'richtext') {
+        const richTextComponent = component;
+        return {
+            id: component.id,
+            type: 'richtext',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            html: resolveRichText(richTextComponent, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}),
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    if (component.type === 'chart') {
+        return layoutChart(component, options);
+    }
+    if (component.type === 'barcode') {
+        const barcodeComponent = component;
+        return {
+            id: component.id,
+            type: 'barcode',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            value: resolveTemplateValue(barcodeComponent.value, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}),
+            format: barcodeComponent.format,
+            showText: barcodeComponent.showText,
+            foregroundColor: barcodeComponent.foregroundColor,
+            font: barcodeComponent.font,
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    if (component.type === 'qrcode') {
+        const qrcodeComponent = component;
+        return {
+            id: component.id,
+            type: 'qrcode',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            value: resolveTemplateValue(qrcodeComponent.value, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}),
+            format: qrcodeComponent.format,
+            foregroundColor: qrcodeComponent.foregroundColor,
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    if (component.type === 'checkbox') {
+        const checkboxComponent = component;
+        return {
+            id: component.id,
+            type: 'checkbox',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            checked: typeof checkboxComponent.checked === 'boolean'
+                ? checkboxComponent.checked
+                : resolveTemplateBoolean(checkboxComponent.checked, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {}),
+            label: checkboxComponent.label
+                ? resolveTemplateValue(checkboxComponent.label, options.context, options.rowsByBand ?? {}, options.pageRowsByBand ?? {})
+                : undefined,
+            foregroundColor: checkboxComponent.foregroundColor,
+            font: checkboxComponent.font,
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    if (component.type === 'table') {
+        return layoutTable(component, options);
+    }
+    if (component.type === 'line') {
+        const lineComponent = component;
+        return {
+            id: component.id,
+            type: 'line',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            startX: lineComponent.startX,
+            startY: lineComponent.startY,
+            endX: lineComponent.endX,
+            endY: lineComponent.endY,
+            lineColor: lineComponent.lineColor,
+            lineWidth: lineComponent.lineWidth,
+            lineStyle: lineComponent.lineStyle,
+        };
+    }
+    if (component.type === 'shape') {
+        const shapeComponent = component;
+        return {
+            id: component.id,
+            type: 'shape',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            shapeType: shapeComponent.shapeType,
+            fillColor: shapeComponent.fillColor,
+            borderColor: shapeComponent.borderColor,
+            borderWidth: shapeComponent.borderWidth,
+            borderStyle: shapeComponent.borderStyle,
+        };
+    }
+    if (component.type === 'pagenumber') {
+        const pageNumberComponent = component;
+        return {
+            id: component.id,
+            type: 'text',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            content: pageNumberContent(pageNumberComponent.format),
+            style: {
+                ...buildBaseRenderStyle(component),
+                font: pageNumberComponent.font,
+                textAlign: pageNumberComponent.textAlign,
+                verticalAlign: pageNumberComponent.verticalAlign ?? 'middle',
+            },
+        };
+    }
+    if (component.type === 'datetime') {
+        const dateTimeComponent = component;
+        return {
+            id: component.id,
+            type: 'text',
+            x: options.x + component.x,
+            y: options.y + component.y,
+            width: component.width,
+            height: component.height,
+            content: formatDateTime(new Date(), dateTimeComponent.format),
+            style: {
+                ...buildBaseRenderStyle(component),
+                font: dateTimeComponent.font,
+                textAlign: dateTimeComponent.textAlign,
+                verticalAlign: dateTimeComponent.verticalAlign ?? 'middle',
+            },
+        };
+    }
+    if (component.type === 'panel') {
+        const panelComponent = component;
+        const panelX = options.x + component.x;
+        const panelY = options.y + component.y;
+        const contentX = panelX + (panelComponent.padding?.left ?? 0);
+        const contentY = panelY + (panelComponent.padding?.top ?? 0);
+        const children = panelComponent.components.map((child) => layoutComponentWithEvents(child, band, {
+            ...options,
+            x: contentX,
+            y: contentY,
+        })).filter((child) => Boolean(child));
+        const overflow = hasContainerOverflow(children, panelX, panelY, component.width, component.height);
+        return {
+            id: component.id,
+            type: 'panel',
+            x: panelX,
+            y: panelY,
+            width: component.width,
+            height: component.height,
+            children,
+            overflow,
+            style: {
+                ...buildBaseRenderStyle(component),
+                backgroundColor: panelComponent.backgroundColor ?? component.backgroundColor,
+                border: panelComponent.border,
+            },
+        };
+    }
+    if (component.type === 'subreport') {
+        const subreportComponent = component;
+        const subreportX = options.x + component.x;
+        const subreportY = options.y + component.y;
+        const rendered = options.renderSubreport?.(subreportComponent, subreportX, subreportY, options.context) ?? {
+            missing: true,
+            children: [createSubreportPlaceholder(subreportComponent, subreportX, subreportY)],
+        };
+        const height = Math.max(component.height, rendered.height ?? component.height);
+        return {
+            id: component.id,
+            type: 'subreport',
+            x: subreportX,
+            y: subreportY,
+            width: component.width,
+            height,
+            templateUrl: subreportComponent.templateUrl,
+            missing: rendered.missing,
+            children: rendered.children,
+            overflow: hasContainerOverflow(rendered.children, subreportX, subreportY, component.width, height),
+            style: buildBaseRenderStyle(component),
+        };
+    }
+    return {
+        id: component.id,
+        type: component.type,
+        x: options.x + component.x,
+        y: options.y + component.y,
+        width: component.width,
+        height: component.height,
+    };
+}
+function layoutTable(component, options) {
+    const effective = resolveTableComponentStyle(component, options.styles ?? []);
+    const tableRows = normalizeRenderableTableRows(effective);
+    const columns = renderColumnsFromRows(effective.width, tableRows);
+    const rows = buildSimpleTableRows(effective, tableRows, {
+        rowsByBand: options.rowsByBand ?? {},
+        pageRowsByBand: options.pageRowsByBand ?? {},
+        context: options.context,
+    });
+    const tableHeight = Math.max(effective.height, tableRows.reduce((sum, row) => sum + (row.height ?? 8), 0));
+    return {
+        id: effective.id,
+        type: 'table',
+        x: options.x + effective.x,
+        y: options.y + effective.y,
+        width: effective.width,
+        height: tableHeight,
+        columns,
+        rows,
+        showBorder: effective.showBorder ?? false,
+        style: buildTableRenderStyle(effective),
+    };
+}
+function resolveTableComponentStyle(component, styles) {
+    const resolved = resolveComponentStyle(component, styles);
+    return {
+        ...component,
+        font: resolved.font,
+        border: resolved.border,
+        backgroundColor: resolved.backgroundColor,
+        padding: resolved.padding,
+        textAlign: resolved.textAlign,
+        verticalAlign: resolved.verticalAlign,
+        format: resolved.format,
+    };
+}
+function buildBaseRenderStyle(component) {
+    const border = component.border;
+    const style = {
+        backgroundColor: component.backgroundColor,
+        border,
+        padding: component.padding,
+    };
+    return Object.values(style).some(value => value !== undefined) ? style : undefined;
+}
+function buildTableRenderStyle(component) {
+    const style = {
+        backgroundColor: component.backgroundColor,
+    };
+    return Object.values(style).some(value => value !== undefined) ? style : undefined;
+}
+function normalizeRenderableTableRows(component) {
+    const sourceRows = component.rows?.length
+        ? component.rows
+        : legacyRenderableTableRows(component);
+    const columnCount = Math.max(1, sourceRows.reduce((count, row) => Math.max(count, renderableColumnCount(row)), 0), component.columnCount ?? 0);
+    return sourceRows.map((row, rowIndex) => ({
+        ...row,
+        id: row.id || `row_${rowIndex + 1}`,
+        height: Math.max(0.1, row.height ?? component.rowHeight ?? 8),
+        cells: normalizeRowCells(row, rowIndex, columnCount),
+    }));
+}
+function renderableColumnCount(row) {
+    return row.cells.reduce((count, cell, sourceIndex) => {
+        const columnIndex = Number.isInteger(cell.column) && cell.column != null && cell.column >= 0
+            ? cell.column
+            : sourceIndex;
+        return Math.max(count, columnIndex + Math.max(1, cell.colSpan ?? 1));
+    }, row.cells.length);
+}
+function normalizeRowCells(row, rowIndex, columnCount) {
+    const positioned = new Map();
+    row.cells.forEach((cell, sourceIndex) => {
+        const columnIndex = Number.isInteger(cell.column) && cell.column != null && cell.column >= 0
+            ? Math.min(cell.column, columnCount - 1)
+            : sourceIndex;
+        positioned.set(columnIndex, cell);
+    });
+    return Array.from({ length: columnCount }, (_, columnIndex) => ({
+        id: positioned.get(columnIndex)?.id ?? `cell_${rowIndex + 1}_${columnIndex + 1}`,
+        ...positioned.get(columnIndex),
+    }));
+}
+function legacyRenderableTableRows(component) {
+    const columnCount = Math.max(1, component.columnCount ?? component.columns?.length ?? 3);
+    const rowCount = Math.max(1, component.rowCount ?? 1);
+    return Array.from({ length: rowCount }, (_, rowIndex) => {
+        return {
+            id: `row_${rowIndex + 1}`,
+            height: component.rowHeight ?? 8,
+            cells: Array.from({ length: columnCount }, (_, columnIndex) => {
+                const cell = component.cells?.find(item => (item.row ?? 0) === rowIndex && (item.column ?? 0) === columnIndex);
+                const column = component.columns?.[columnIndex];
+                return {
+                    id: `cell_${rowIndex + 1}_${columnIndex + 1}`,
+                    ...cell,
+                    text: cell?.text ?? (column?.field ? `{${column.field}}` : undefined),
+                    width: cell?.width ?? column?.width,
+                };
+            }),
+        };
+    });
+}
+function renderColumnsFromRows(tableWidth, rows) {
+    const firstRow = rows[0] ?? { cells: [] };
+    const widths = resolveRenderRowWidths(firstRow, tableWidth);
+    return widths.map((width, index) => ({
+        id: `col_${index + 1}`,
+        header: `Column ${index + 1}`,
+        field: '',
+        width,
+        cellType: 'text',
+    }));
+}
+function resolveRenderRowWidths(row, rowWidth) {
+    const fixed = row.cells.reduce((sum, cell) => sum + (cell.width ?? 0), 0);
+    const autoCount = row.cells.filter(cell => cell.width == null).length;
+    const autoWidth = autoCount > 0 ? Math.max(0, rowWidth - fixed) / autoCount : 0;
+    return row.cells.map(cell => Math.round((cell.width ?? autoWidth) * 10) / 10);
+}
+function buildSimpleTableRows(component, rows, options) {
+    const covered = new Set();
+    return rows.map((row, rowIndex) => {
+        const renderedRow = [];
+        row.cells.forEach((cell, columnIndex) => {
+            if (covered.has(`${rowIndex}-${columnIndex}`))
+                return;
+            const rowSpan = Math.max(1, Math.min(cell.rowSpan ?? 1, rows.length - rowIndex));
+            const colSpan = Math.max(1, Math.min(cell.colSpan ?? 1, row.cells.length - columnIndex));
+            markCoveredCells(covered, rowIndex, columnIndex, rowSpan, colSpan);
+            renderedRow.push({
+                row: rowIndex,
+                column: columnIndex,
+                content: tableCellContent({
+                    cell,
+                    column: { id: `col_${columnIndex + 1}`, header: '', field: '', width: 0, cellType: 'text' },
+                    context: options.context,
+                    rowsByBand: options.rowsByBand,
+                    pageRowsByBand: options.pageRowsByBand,
+                }),
+                rowSpan,
+                colSpan,
+                height: row.height ?? 8,
+                style: resolvedRenderTableCellStyle(component, row, cell, rowIndex, columnIndex),
+            });
+        });
+        return renderedRow;
+    });
+}
+function resolvedRenderTableCellStyle(component, row, cell, rowIndex, columnIndex) {
+    const rowStyle = row.style ?? {};
+    const cellStyle = cell.style ?? {};
+    const border = cell.border
+        ?? cellStyle.border
+        ?? row.border
+        ?? rowStyle.border
+        ?? component.border;
+    const style = {
+        backgroundColor: cell.backgroundColor ?? cellStyle.backgroundColor ?? row.backgroundColor ?? rowStyle.backgroundColor ?? component.backgroundColor,
+        font: mergeTableFonts(component.font, rowStyle.font, row.font, cellStyle.font, cell.font),
+        border: collapsedRenderBorder(border, rowIndex, columnIndex),
+        padding: cell.padding ?? cellStyle.padding ?? row.padding ?? rowStyle.padding ?? component.padding,
+        textAlign: cell.textAlign ?? cellStyle.textAlign ?? row.textAlign ?? rowStyle.textAlign ?? component.textAlign,
+        verticalAlign: cell.verticalAlign ?? cellStyle.verticalAlign ?? row.verticalAlign ?? rowStyle.verticalAlign ?? component.verticalAlign,
+        format: cell.format ?? cellStyle.format ?? row.format ?? rowStyle.format ?? component.format,
+    };
+    return Object.values(style).some(value => value !== undefined) ? style : undefined;
+}
+function mergeTableFonts(...fonts) {
+    const merged = fonts.reduce((next, font) => {
+        if (!font)
+            return next;
+        Object.entries(font).forEach(([key, value]) => {
+            if (value !== undefined) {
+                next[key] = value;
+            }
+        });
+        return next;
+    }, {});
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function collapsedRenderBorder(border, rowIndex, columnIndex) {
+    if (!border || border.style === 'none' || !border.width)
+        return undefined;
+    return {
+        ...border,
+        sides: {
+            top: rowIndex === 0 && Boolean(border.sides.top),
+            left: columnIndex === 0 && Boolean(border.sides.left),
+            right: Boolean(border.sides.right),
+            bottom: Boolean(border.sides.bottom),
+        },
+    };
+}
+function layoutChart(component, options) {
+    const chartX = options.x + component.x;
+    const chartY = options.y + component.y;
+    const rows = resolveChartRows(component, options);
+    const sortedRows = applyChartSort(rows, component.binding?.sort ?? [], options.context);
+    const aggregate = resolveChartAggregate(component);
+    const data = buildChartData(component, sortedRows, aggregate, options);
+    return {
+        id: component.id,
+        type: 'chart',
+        x: chartX,
+        y: chartY,
+        width: component.width,
+        height: component.height,
+        chartType: component.chartType,
+        data,
+        rawData: sortedRows,
+        binding: component.binding ?? { dimensions: [], measures: [], sort: [] },
+        title: component.title?.text,
+        subtitle: component.title?.subtitle,
+        showLegend: component.legend?.visible ?? true,
+        legendPosition: component.legend?.position ?? 'bottom',
+        showAxes: component.axes?.x?.visible ?? component.axes?.y?.visible ?? true,
+        showGrid: component.axes?.x?.gridVisible ?? component.axes?.y?.gridVisible ?? true,
+        showLabels: component.labels?.visible ?? false,
+        labelType: component.labels?.content === 'custom' ? undefined : component.labels?.content,
+        axisTitleX: component.axes?.x?.title,
+        axisTitleY: component.axes?.y?.title,
+        axisLabelRotation: component.axes?.x?.labelRotate,
+        titleConfig: component.title,
+        legendConfig: component.legend,
+        axesConfig: component.axes,
+        labelsConfig: component.labels,
+        theme: component.theme,
+        plotOptions: component.plotOptions,
+        aggregate,
+        emptyMessage: component.emptyMessage ?? 'No data',
+        style: buildBaseRenderStyle(component),
+    };
+}
+/**
+ * 聚合模式：binding.aggregate 已删除，改由 measure.aggregation 推导。
+ * 取第一个度量（或 dualAxis 的 left 度量）的 aggregation，缺省为 'none'。
+ */
+function resolveChartAggregate(component) {
+    const measures = component.binding?.measures ?? [];
+    const caps = getChartCapabilities(component.chartType);
+    const index = caps.measures === 'dualAxis' ? measures.findIndex(m => m.axis !== 'right') : 0;
+    const measure = measures[index < 0 ? 0 : index];
+    return measure?.aggregation ?? 'none';
+}
+function resolveChartRows(component, options) {
+    const binding = component.binding;
+    const dataSourceId = binding?.dataSourceId;
+    if (binding?.arrayPath && options.context.row) {
+        const nested = asRecordArray(valueAtPath(options.context.row, binding.arrayPath));
+        if (nested.length > 0)
+            return nested;
+    }
+    if (!dataSourceId) {
+        return options.context.row ? [options.context.row] : [];
+    }
+    if (dataSourceId === options.context.dataSourceId && options.context.row) {
+        return [options.context.row];
+    }
+    return options.context.rowsByBand?.[dataSourceId] ?? options.rowsByBand?.[dataSourceId] ?? [];
+}
+function applyChartSort(rows, sort, context) {
+    if (sort.length === 0)
+        return rows;
+    return [...rows].sort((left, right) => {
+        for (const rule of sort) {
+            const leftValue = resolveChartExpressionValue(rule.field, left, context);
+            const rightValue = resolveChartExpressionValue(rule.field, right, context);
+            const order = compareChartValues(leftValue, rightValue);
+            if (order !== 0) {
+                return rule.direction === 'desc' ? -order : order;
+            }
+        }
+        return 0;
+    });
+}
+function buildChartData(component, rows, aggregate, options) {
+    const caps = getChartCapabilities(component.chartType);
+    const binding = component.binding ?? {};
+    const dimensions = binding.dimensions ?? [];
+    const measures = binding.measures ?? [];
+    const supportsSeriesField = caps.series === 'fieldOrMeasureNames';
+    const seriesField = supportsSeriesField ? binding.seriesField : undefined;
+    const measureFields = measures.map(measure => measure.field).filter(Boolean);
+    const isScatter = component.chartType === 'scatter';
+    const isHeatmap = component.chartType === 'heatmap';
+    const isSankey = component.chartType === 'sankey';
+    const isHierarchical = caps.dimensions === 'hierarchical';
+    const points = rows.flatMap((row) => {
+        const measureValues = resolveMeasureValues(row, measureFields);
+        const measureKey = measures[0]?.field;
+        if (isScatter) {
+            const x = resolveNumber(row[dimensions[0]?.field ?? '']);
+            const y = resolveNumber(row[measures[0]?.field ?? '']);
+            return {
+                category: x == null ? '' : String(x),
+                value: y,
+                measureValues,
+                measureKey,
+                label: x == null ? undefined : String(x),
+                x, y,
+                raw: row,
+            };
+        }
+        if (isHeatmap) {
+            const category = readField(row, dimensions[0]?.field);
+            const series = readField(row, dimensions[1]?.field);
+            const value = resolveNumber(row[measures[0]?.field ?? '']);
+            return {
+                category: category == null ? '' : String(category),
+                value,
+                measureValues,
+                measureKey,
+                series: series == null ? undefined : String(series),
+                label: category == null ? undefined : String(category),
+                x: null,
+                y: value,
+                raw: row,
+            };
+        }
+        if (isSankey) {
+            const source = readField(row, dimensions[0]?.field);
+            const target = readField(row, dimensions[1]?.field);
+            const value = resolveNumber(row[measures[0]?.field ?? '']);
+            return {
+                category: source == null ? '' : String(source),
+                value,
+                measureValues,
+                measureKey,
+                source: source == null ? undefined : String(source),
+                target: target == null ? undefined : String(target),
+                label: source == null ? undefined : String(source),
+                x: null,
+                y: value,
+                raw: row,
+            };
+        }
+        if (isHierarchical) {
+            const path = dimensions.map(d => readField(row, d.field)).filter(v => v != null).map(String);
+            const value = resolveNumber(row[measures[0]?.field ?? '']);
+            return {
+                category: path[0] ?? '',
+                value,
+                measureValues,
+                measureKey,
+                path: path.length > 0 ? path : undefined,
+                label: path[path.length - 1],
+                x: null,
+                y: value,
+                raw: row,
+            };
+        }
+        // 笛卡尔分类图（single 维度）：按 measure 展开。
+        const category = readField(row, dimensions[0]?.field);
+        const boundSeries = readField(row, seriesField);
+        const series = boundSeries == null ? undefined : String(boundSeries);
+        const basePoint = {
+            category: category == null ? '' : String(category),
+            value: null,
+            measureValues,
+            measureKey,
+            series,
+            label: category == null ? undefined : String(category),
+            x: null,
+            y: null,
+            raw: row,
+        };
+        if (caps.measures === 'multi' || caps.measures === 'dualAxis') {
+            if (seriesField && measures[0]) {
+                const value = resolveNumber(row[measures[0].field]);
+                return {
+                    ...basePoint,
+                    value,
+                    y: value,
+                    measureKey: measures[0].field,
+                    axis: caps.measures === 'dualAxis' ? (measures[0].axis ?? 'left') : undefined,
+                };
+            }
+            // 未绑定系列字段时，每个度量展开为一个 point（即一个系列）。
+            return measures.map(measure => {
+                const value = resolveNumber(row[measure.field]);
+                return {
+                    ...basePoint,
+                    value,
+                    y: value,
+                    measureKey: measure.field,
+                    series: measure.alias || measure.field,
+                    axis: caps.measures === 'dualAxis' ? (measure.axis ?? 'left') : undefined,
+                };
+            });
+        }
+        // 单度量
+        const value = resolveNumber(row[measures[0]?.field ?? '']);
+        return {
+            ...basePoint,
+            value,
+            y: value,
+        };
+    });
+    if (aggregate === 'none')
+        return points;
+    return aggregateChartPoints(points, isScatter, aggregate);
+}
+function readField(row, field) {
+    if (!field)
+        return undefined;
+    return row[field];
+}
+function aggregateChartPoints(points, isScatter, aggregate) {
+    const grouped = new Map();
+    for (const point of points) {
+        const key = isScatter
+            ? `${point.x ?? point.category}::${point.series ?? ''}`
+            : `${point.category}::${point.series ?? ''}`;
+        const entry = grouped.get(key);
+        if (!entry) {
+            grouped.set(key, {
+                point,
+                values: point.value == null ? [] : [point.value],
+                measureValues: collectMeasureValues(point),
+                count: 1,
+            });
+            continue;
+        }
+        entry.count += 1;
+        if (point.value != null)
+            entry.values.push(point.value);
+        mergeMeasureValues(entry.measureValues, point);
+    }
+    return Array.from(grouped.values()).map(({ point, values, measureValues, count }) => {
+        const value = aggregateValues(values, count, aggregate);
+        return {
+            ...point,
+            value,
+            measureValues: aggregateMeasureValues(measureValues, count, aggregate),
+            y: point.x == null ? value : (point.y ?? value),
+            x: point.x ?? null,
+        };
+    });
+}
+function resolveMeasureValues(row, fields) {
+    if (fields.length === 0)
+        return undefined;
+    return Object.fromEntries(fields.map(field => [field, resolveNumber(row[field])]));
+}
+function collectMeasureValues(point) {
+    const values = {};
+    mergeMeasureValues(values, point);
+    return values;
+}
+function mergeMeasureValues(target, point) {
+    for (const [field, value] of Object.entries(point.measureValues ?? {})) {
+        if (value == null)
+            continue;
+        target[field] = [...(target[field] ?? []), value];
+    }
+}
+function aggregateMeasureValues(values, count, aggregate) {
+    const entries = Object.entries(values);
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries.map(([field, fieldValues]) => [field, aggregateValues(fieldValues, count, aggregate)]));
+}
+function aggregateValues(values, count, aggregate) {
+    if (aggregate === 'count')
+        return count;
+    if (values.length === 0)
+        return null;
+    if (aggregate === 'min')
+        return Math.min(...values);
+    if (aggregate === 'max')
+        return Math.max(...values);
+    if (aggregate === 'avg')
+        return values.reduce((sum, value) => sum + value, 0) / values.length;
+    return values.reduce((sum, value) => sum + value, 0);
+}
+function resolveChartExpressionValue(expression, row, context) {
+    if (!expression)
+        return undefined;
+    try {
+        return evalExpression(expression, (source, field) => resolveFieldForChart(row, context, source, field), context.rowIndex, expressionVariables(context, { row }), new AggregateRuntime({ rowsByBand: context.rowsByBand ?? {}, pageRowsByBand: {}, defaultDataSourceId: context.dataSourceId }), context.expressionFunctions);
+    }
+    catch {
+        return expression;
+    }
+}
+function resolveFieldForChart(row, context, source, field) {
+    if (['Parameter', 'Parameters', 'Params'].includes(source)) {
+        return context.parameters?.[field];
+    }
+    if (!source && context.parameters && field in context.parameters) {
+        return context.parameters[field];
+    }
+    if (!source && context.expressionVariables && field in context.expressionVariables) {
+        return context.expressionVariables[field];
+    }
+    const scoped = row[source];
+    if (scoped && typeof scoped === 'object' && !Array.isArray(scoped)) {
+        return scoped[field];
+    }
+    return row[field] ?? row[`${source}.${field}`] ?? context.groupValues[field];
+}
+function compareChartValues(left, right) {
+    if (left == null && right == null)
+        return 0;
+    if (left == null)
+        return -1;
+    if (right == null)
+        return 1;
+    const leftNumber = Number(left);
+    const rightNumber = Number(right);
+    if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {
+        return leftNumber - rightNumber;
+    }
+    return String(left).localeCompare(String(right));
+}
+function resolveNumber(value) {
+    if (value == null || value === '')
+        return null;
+    const numberValue = typeof value === 'number' ? value : Number(value);
+    return Number.isFinite(numberValue) ? numberValue : null;
+}
+function valueAtPath(row, path) {
+    return path.split('.').filter(Boolean).reduce((value, segment) => {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            return value[segment];
+        }
+        return undefined;
+    }, row);
+}
+function asRecordArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => Boolean(item) && typeof item === 'object' && !Array.isArray(item))
+        : [];
+}
+function createSubreportPlaceholder(component, x, y) {
+    return {
+        id: `${component.id}-missing-placeholder`,
+        type: 'text',
+        x,
+        y,
+        width: component.width,
+        height: component.height,
+        content: `Missing subreport: ${component.templateUrl}`,
+    };
+}
+function hasContainerOverflow(children, x, y, width, height) {
+    return children.some(child => (Boolean(child.overflow)
+        || child.x < x
+        || child.y < y
+        || child.x + child.width > x + width
+        || child.y + child.height > y + height));
+}
+function markCoveredCells(covered, row, column, rowSpan, colSpan) {
+    for (let coveredRow = row; coveredRow < row + rowSpan; coveredRow += 1) {
+        for (let coveredColumn = column; coveredColumn < column + colSpan; coveredColumn += 1) {
+            if (coveredRow === row && coveredColumn === column)
+                continue;
+            covered.add(`${coveredRow}-${coveredColumn}`);
+        }
+    }
+}
+function tableCellContent(options) {
+    if (options.cell?.text) {
+        const value = resolveTableCellText(options.cell.text, options.context, options.rowsByBand, options.pageRowsByBand);
+        return formatValue(value, options.cell.format);
+    }
+    if (!options.column.field) {
+        return '';
+    }
+    const value = options.context.row?.[options.column.field] ?? options.context.row?.[`${options.context.dataSourceId}.${options.column.field}`];
+    return formatValue(value, options.cell?.format);
+}
+function resolveTableCellText(text, context, rowsByBand, pageRowsByBand) {
+    if (text.includes('{PageNumber}') || text.includes('{TotalPages}')) {
+        return text;
+    }
+    if (!text.includes('{') && !text.includes('(') && !text.includes('=')) {
+        return text;
+    }
+    try {
+        return evalExpression(text, (source, field) => resolveField(context, source, field), context.rowIndex, expressionVariables(context), new AggregateRuntime({ rowsByBand: context.rowsByBand ?? rowsByBand, pageRowsByBand, defaultDataSourceId: context.dataSourceId }), context.expressionFunctions);
+    }
+    catch {
+        return resolveTemplateValue(text, context, rowsByBand, pageRowsByBand);
+    }
+}
+function resolveTemplateBoolean(value, context, rowsByBand, pageRowsByBand) {
+    const resolved = resolveTemplateValue(value, context, rowsByBand, pageRowsByBand).trim().toLowerCase();
+    if (['true', '1', 'yes', 'y'].includes(resolved))
+        return true;
+    if (['false', '0', 'no', 'n', ''].includes(resolved))
+        return false;
+    return Boolean(resolved);
+}
+function pageNumberContent(format) {
+    switch (format) {
+        case '1':
+            return '{PageNumber}';
+        case 'Page 1':
+            return 'Page {PageNumber}';
+        case 'Page 1 of N':
+            return 'Page {PageNumber} of {TotalPages}';
+        case '1/N':
+        default:
+            return '{PageNumber}/{TotalPages}';
+    }
+}
+function formatDateTime(date, pattern) {
+    const parts = {
+        yyyy: String(date.getFullYear()).padStart(4, '0'),
+        MM: String(date.getMonth() + 1).padStart(2, '0'),
+        dd: String(date.getDate()).padStart(2, '0'),
+        HH: String(date.getHours()).padStart(2, '0'),
+        mm: String(date.getMinutes()).padStart(2, '0'),
+        ss: String(date.getSeconds()).padStart(2, '0'),
+    };
+    return pattern.replace(/yyyy|MM|dd|HH|mm|ss/g, token => parts[token] ?? token);
+}
+function resolveText(component, context, rowsByBand, pageRowsByBand, execution) {
+    if (execution?.hasValue) {
+        return formatValue(execution.value, component.format);
+    }
+    if (component.text.includes('{PageNumber}') || component.text.includes('{TotalPages}')) {
+        return component.text;
+    }
+    if (!component.text.includes('{') && !component.text.includes('(') && !component.text.includes('=')) {
+        return component.text;
+    }
+    try {
+        const value = evalExpression(component.text, (source, field) => resolveField(context, source, field), context.rowIndex, expressionVariables(context), new AggregateRuntime({ rowsByBand: context.rowsByBand ?? rowsByBand, pageRowsByBand, defaultDataSourceId: context.dataSourceId }), context.expressionFunctions);
+        return formatValue(value, component.format);
+    }
+    catch {
+        return resolveTemplateValue(component.text, context, rowsByBand, pageRowsByBand);
+    }
+}
+function resolveRichText(component, context, rowsByBand, pageRowsByBand) {
+    return resolveTemplateValue(component.html, context, rowsByBand, pageRowsByBand);
+}
+function resolveTemplateValue(value, context, rowsByBand, pageRowsByBand) {
+    if (!value.includes('{') && !value.includes('(') && !value.includes('=')) {
+        return value;
+    }
+    const runtime = new AggregateRuntime({ rowsByBand: context.rowsByBand ?? rowsByBand, pageRowsByBand, defaultDataSourceId: context.dataSourceId });
+    const evaluateTextExpression = (expression) => {
+        const result = evalExpression(expression, (source, field) => resolveField(context, source, field), context.rowIndex, expressionVariables(context), runtime, context.expressionFunctions);
+        return result == null ? '' : String(result);
+    };
+    const placeholderPattern = /\{([^{}]+)\}/g;
+    const isSinglePlaceholder = value.trim().match(/^\{([^{}]+)\}$/);
+    const withFunctions = replaceEmbeddedFunctionCalls(value, (expression) => {
+        try {
+            return evaluateTextExpression(expression);
+        }
+        catch {
+            return expression;
+        }
+    });
+    if (withFunctions !== value) {
+        return resolveTemplateValue(withFunctions, context, rowsByBand, pageRowsByBand);
+    }
+    if (!isSinglePlaceholder && placeholderPattern.test(value)) {
+        return value.replace(/\{([^{}]+)\}/g, (match, expressionBody) => {
+            try {
+                return evaluateTextExpression(`{${expressionBody}}`);
+            }
+            catch {
+                return match;
+            }
+        });
+    }
+    try {
+        return evaluateTextExpression(value);
+    }
+    catch {
+        return value;
+    }
+}
+function replaceEmbeddedFunctionCalls(value, replace) {
+    let output = '';
+    let index = 0;
+    while (index < value.length) {
+        const start = findNextFunctionStart(value, index);
+        if (start < 0) {
+            output += value.slice(index);
+            break;
+        }
+        const end = findFunctionCallEnd(value, start);
+        if (end < 0) {
+            output += value.slice(index);
+            break;
+        }
+        output += value.slice(index, start);
+        output += replace(value.slice(start, end));
+        index = end;
+    }
+    return output;
+}
+function findNextFunctionStart(value, from) {
+    for (let index = from; index < value.length; index += 1) {
+        if (!isIdentifierStart(value[index])) {
+            continue;
+        }
+        const previous = index > 0 ? value[index - 1] : '';
+        if (isIdentifierPart(previous)) {
+            continue;
+        }
+        let cursor = index + 1;
+        while (cursor < value.length && isIdentifierPart(value[cursor])) {
+            cursor += 1;
+        }
+        if (value[cursor] === '(') {
+            return index;
+        }
+    }
+    return -1;
+}
+function findFunctionCallEnd(value, start) {
+    const open = value.indexOf('(', start);
+    if (open < 0)
+        return -1;
+    let depth = 0;
+    let inString = false;
+    let inFieldRef = false;
+    for (let index = open; index < value.length; index += 1) {
+        const char = value[index];
+        const previous = index > 0 ? value[index - 1] : '';
+        if (inString) {
+            if (char === '"' && previous !== '\\') {
+                inString = false;
+            }
+            continue;
+        }
+        if (inFieldRef) {
+            if (char === '}') {
+                inFieldRef = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            continue;
+        }
+        if (char === '{') {
+            inFieldRef = true;
+            continue;
+        }
+        if (char === '(') {
+            depth += 1;
+            continue;
+        }
+        if (char === ')') {
+            depth -= 1;
+            if (depth === 0) {
+                return index + 1;
+            }
+        }
+    }
+    return -1;
+}
+function isIdentifierStart(char) {
+    return Boolean(char && /[A-Za-z_]/.test(char));
+}
+function isIdentifierPart(char) {
+    return Boolean(char && /[A-Za-z0-9_.]/.test(char));
+}
+function resolveTextComponentStyle(component, styles) {
+    const resolved = resolveTextStyle(component, styles);
+    return {
+        ...component,
+        font: resolved.font,
+        border: resolved.border,
+        backgroundColor: resolved.backgroundColor,
+        textAlign: resolved.textAlign,
+        verticalAlign: resolved.verticalAlign,
+        padding: resolved.padding,
+        format: resolved.format,
+        canGrow: resolved.canGrow,
+        canShrink: resolved.canShrink,
+    };
+}
+function applyTextConditionalFormats(component, sourceComponent, options) {
+    const baseStyle = {
+        font: component.font,
+        background: component.backgroundColor,
+        border: component.border,
+        padding: component.padding,
+        textAlign: component.textAlign,
+        verticalAlign: component.verticalAlign,
+        format: component.format,
+        canGrow: component.canGrow,
+        canShrink: component.canShrink,
+        enabled: true,
+    };
+    return applyConditionalFormatsToStyle(baseStyle, options.conditionalFormats ?? [], sourceComponent, {
+        resolveField: (source, field) => resolveField(options.context, source, field),
+        rowIndex: options.context.rowIndex,
+        variables: expressionVariables(options.context),
+        functions: options.context.expressionFunctions,
+        reportRuntime: new AggregateRuntime({
+            rowsByBand: options.context.rowsByBand ?? options.rowsByBand ?? {},
+            pageRowsByBand: options.pageRowsByBand ?? {},
+            defaultDataSourceId: options.context.dataSourceId,
+        }),
+    });
+}
+function expressionVariables(context, extra = {}) {
+    return {
+        row: context.row,
+        groupValues: context.groupValues,
+        parameters: context.parameters,
+        ...extra,
+        ...(context.expressionVariables ?? {}),
+    };
+}
+function resolveField(context, source, field) {
+    if (['Parameter', 'Parameters', 'Params'].includes(source)) {
+        return context.parameters?.[field];
+    }
+    if (!source && context.parameters && field in context.parameters) {
+        return context.parameters[field];
+    }
+    if (!source && context.expressionVariables && field in context.expressionVariables) {
+        return context.expressionVariables[field];
+    }
+    if (source === 'Group' || source === 'Groups') {
+        return context.groupValues[field];
+    }
+    const row = context.row ?? {};
+    const scoped = row[source];
+    if (scoped && typeof scoped === 'object' && !Array.isArray(scoped)) {
+        return scoped[field];
+    }
+    return row[field] ?? row[`${source}.${field}`] ?? context.groupValues[field];
+}
+//# sourceMappingURL=layout-band.js.map