@firestitch/report 18.0.0

package/esm2022/app/reports/export/report-pptx.service.mjs

@@ -0,0 +1,224 @@
+import { Injectable } from '@angular/core';
+import { format } from 'date-fns';
+import { formatMeasureValue } from '../format';
+import { pageGeometry } from '../layout';
+import { extractChartSeries, formatPeriodLabel, isColorBy, resolveLegendPosition, spansMultipleYears } from '../option-builder';
+import { REPORT_CHART_COLORS } from '../theme/palette';
+import * as i0 from "@angular/core";
+// Component title strip height on the slide, inches.
+const TITLE_H = 0.28;
+// Approximate table row height, inches — drives the rows-that-fit cap.
+const TABLE_ROW_H = 0.26;
+// Our legend positions mapped to pptxgenjs's single-letter legendPos codes.
+// 'hidden' has no slot — showLegend is turned off instead — so it falls back
+// to top.
+const PPTX_LEGEND_POS = {
+    top: 't',
+    bottom: 'b',
+    left: 'l',
+    right: 'r',
+    hidden: 't',
+};
+// Builds the PowerPoint deck client-side with pptxgenjs. Charts are NATIVE
+// editable PowerPoint charts (slide.addChart writes real chart XML with an
+// embedded data workbook — "Edit Data" works), never images. The page IS the
+// slide: the report's unit is inches — exactly PowerPoint's unit — so the
+// layout and every component position transfer with no conversion at all.
+// pptxgenjs is loaded lazily so it lives in its own webpack chunk.
+export class ReportPptxService {
+    async export(collected) {
+        const PptxGenJS = (await import('pptxgenjs')).default;
+        const report = collected.report;
+        const pageW = report.pageWidth;
+        const pageH = report.pageHeight;
+        const pptx = new PptxGenJS();
+        pptx.defineLayout({ name: 'REPORT', width: pageW, height: pageH });
+        pptx.layout = 'REPORT';
+        pptx.title = report.name;
+        this._titleSlide(pptx, collected, pageW, pageH);
+        for (const collectedPage of collected.pages) {
+            const slide = pptx.addSlide();
+            const geometry = pageGeometry(report, collectedPage.page);
+            for (const item of collectedPage.components) {
+                this._renderComponent(pptx, slide, item, geometry.get(item.component.id));
+            }
+        }
+        await pptx.writeFile({ fileName: `${this._slug(report.name)}.pptx` });
+    }
+    _titleSlide(pptx, collected, pageW, pageH) {
+        const slide = pptx.addSlide();
+        slide.addText(collected.report.name, {
+            x: 0.5, y: pageH * 0.3, w: pageW - 1, h: 0.8,
+            fontSize: 30, bold: true, color: '1F2933',
+        });
+        const lines = [
+            format(new Date(), 'MMMM d, yyyy'),
+            ...collected.filterSummary,
+        ];
+        slide.addText(lines.join('\n'), {
+            x: 0.5, y: pageH * 0.3 + 0.9, w: pageW - 1, h: Math.max(0.4, lines.length * 0.25),
+            fontSize: 12, color: '52606D',
+        });
+    }
+    _renderComponent(pptx, slide, item, geometry) {
+        const component = item.component;
+        // Geometry is in inches — PowerPoint's native unit (flow layout arrives
+        // pre-resolved into rows by pageGeometry).
+        const { x, y, w, h } = geometry ?? component;
+        if (component.title) {
+            slide.addText(component.title, {
+                x, y, w, h: TITLE_H,
+                fontSize: 10, bold: true, color: '1F2933', valign: 'top',
+            });
+        }
+        const bodyY = y + TITLE_H;
+        const bodyH = Math.max(0.3, h - TITLE_H);
+        if (!item.data || !item.data.rows?.length) {
+            slide.addText(item.data ? 'No data' : 'Data unavailable', {
+                x, y: bodyY, w, h: bodyH,
+                fontSize: 10, italic: true, color: '7B8794', align: 'center', valign: 'middle',
+            });
+            return;
+        }
+        switch (component.type) {
+            case 'chart':
+                this._renderChart(pptx, slide, component, item.data, x, bodyY, w, bodyH);
+                break;
+            case 'list':
+                this._renderTable(slide, component, item.data, x, bodyY, w, bodyH);
+                break;
+            case 'kpi':
+                this._renderKpi(slide, component, item.data, x, bodyY, w, bodyH);
+                break;
+        }
+    }
+    _renderChart(pptx, slide, component, data, x, y, w, h) {
+        const config = component.config;
+        const chartType = config.chartType ?? 'bar';
+        const extracted = extractChartSeries(component, data);
+        const typeMap = {
+            bar: pptx.ChartType.bar,
+            line: pptx.ChartType.line,
+            area: pptx.ChartType.area,
+            pie: pptx.ChartType.pie,
+            donut: pptx.ChartType.doughnut,
+        };
+        const pie = chartType === 'pie' || chartType === 'donut';
+        const colorBy = isColorBy(config);
+        // Compact period labels match the on-screen axis (year only when the data
+        // spans years); PowerPoint can't do a styled second line, so it's inline.
+        const granularity = data.granularity;
+        const labels = granularity
+            ? extracted.categories.map((category) => formatPeriodLabel(category, granularity, spansMultipleYears(extracted.categories)))
+            : extracted.categories;
+        // Native chart data: one entry per series (pie charts take exactly one).
+        // colorBy emits one series per category for the on-screen overlap; PowerPoint
+        // has no equivalent overlap, so collapse them back into a single series (each
+        // category's value sits at its own slot) — one full-width bar per category —
+        // rather than letting PowerPoint cluster them into slivers.
+        const chartData = colorBy
+            ? [{
+                    name: config.measures?.[0]?.label ?? config.colorBy?.label ?? '',
+                    labels,
+                    values: extracted.categories.map((_, index) => extracted.series[index]?.values[index] ?? 0),
+                }]
+            : (pie ? extracted.series.slice(0, 1) : extracted.series)
+                .map((series) => ({
+                name: series.name,
+                labels,
+                values: series.values.map((value) => value ?? 0),
+            }));
+        // A single-series colorBy chart can't carry a per-category legend in a native
+        // PowerPoint bar chart; the category axis labels identify each bar instead.
+        const legendPosition = colorBy
+            ? 'hidden'
+            : resolveLegendPosition(config, extracted.series.length);
+        slide.addChart(typeMap[chartType], chartData, {
+            x, y, w, h,
+            chartColors: REPORT_CHART_COLORS,
+            showLegend: legendPosition !== 'hidden',
+            legendPos: PPTX_LEGEND_POS[legendPosition],
+            legendFontSize: 9,
+            barDir: config.orientation === 'horizontal' ? 'bar' : 'col',
+            barGrouping: config.stacked ? 'stacked' : 'clustered',
+            holeSize: chartType === 'donut' ? 55 : undefined,
+            catAxisLabelFontSize: 9,
+            valAxisLabelFontSize: 9,
+            showCatAxisTitle: !!config.xAxis?.label,
+            catAxisTitle: config.xAxis?.label,
+            catAxisTitleFontSize: 10,
+            showValAxisTitle: !!config.measures?.[0]?.label && !pie,
+            valAxisTitle: config.measures?.[0]?.label,
+            valAxisTitleFontSize: 10,
+            dataBorder: { pt: 0, color: 'FFFFFF' },
+        });
+    }
+    _renderTable(slide, component, data, x, y, w, h) {
+        const config = component.config;
+        const columns = config.columns?.length
+            ? config.columns
+            : data.columns.map((column) => ({ column, label: column }));
+        const cap = Math.max(2, Math.floor(h / TABLE_ROW_H) - 1);
+        const rows = data.rows.slice(0, cap);
+        const remaining = (data.paging?.total ?? data.rows.length) - rows.length;
+        const header = columns.map((column) => ({
+            text: column.label || column.column,
+            options: { bold: true, color: 'FFFFFF', fill: { color: '4E79A7' } },
+        }));
+        const body = rows.map((row) => columns.map((column) => ({
+            text: this._cell(row[column.column], column.format),
+            options: {},
+        })));
+        if (remaining > 0) {
+            body.push([{
+                    text: `… ${remaining} more row(s) — use the component's CSV export for the full dataset`,
+                    options: { colspan: columns.length, italic: true, color: '7B8794' },
+                }]);
+        }
+        slide.addTable([header, ...body], {
+            x, y, w,
+            fontSize: 9,
+            color: '1F2933',
+            border: { type: 'solid', pt: 0.5, color: 'E4E7EB' },
+            autoPage: false,
+            rowH: TABLE_ROW_H,
+            valign: 'middle',
+        });
+    }
+    _renderKpi(slide, component, data, x, y, w, h) {
+        const config = component.config;
+        const row = data.rows[0] ?? {};
+        const column = config.measure?.column ?? Object.keys(row)[0];
+        const value = formatMeasureValue(row[column], config.measure?.format);
+        slide.addText([
+            { text: value, options: { fontSize: 28, bold: true, color: '1F2933', breakLine: true } },
+            { text: config.measure?.label ?? '', options: { fontSize: 10, color: '7B8794' } },
+        ], {
+            x, y, w, h,
+            align: 'center',
+            valign: 'middle',
+        });
+    }
+    _cell(value, columnFormat) {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        if (columnFormat === 'date') {
+            const date = new Date(String(value));
+            return Number.isNaN(date.getTime()) ? String(value) : format(date, 'MMM d, yyyy');
+        }
+        if (columnFormat === 'number') {
+            return formatMeasureValue(value, 'number');
+        }
+        return String(value);
+    }
+    _slug(name) {
+        return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'report';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportPptxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportPptxService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ReportPptxService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-pptx.service.js","sourceRoot":"","sources":["../../../../../src/app/reports/export/report-pptx.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { format } from 'date-fns';\n\nimport { formatMeasureValue } from '../format';\nimport {\n  ChartConfig,\n  ComponentData,\n  LegendPosition,\n  ListConfig,\n  KpiConfig,\n  ReportComponent,\n} from '../interfaces/report.interface';\nimport { ComponentGeometry, pageGeometry } from '../layout';\nimport { extractChartSeries, formatPeriodLabel, isColorBy, resolveLegendPosition, spansMultipleYears } from '../option-builder';\nimport { REPORT_CHART_COLORS } from '../theme/palette';\nimport { CollectedComponent, CollectedReport } from './report-export-collector.service';\n\n\n// Component title strip height on the slide, inches.\nconst TITLE_H = 0.28;\n// Approximate table row height, inches — drives the rows-that-fit cap.\nconst TABLE_ROW_H = 0.26;\n\n// Our legend positions mapped to pptxgenjs's single-letter legendPos codes.\n// 'hidden' has no slot — showLegend is turned off instead — so it falls back\n// to top.\nconst PPTX_LEGEND_POS: Record<LegendPosition, 't' | 'b' | 'l' | 'r'> = {\n  top: 't',\n  bottom: 'b',\n  left: 'l',\n  right: 'r',\n  hidden: 't',\n};\n\n// Builds the PowerPoint deck client-side with pptxgenjs. Charts are NATIVE\n// editable PowerPoint charts (slide.addChart writes real chart XML with an\n// embedded data workbook — \"Edit Data\" works), never images. The page IS the\n// slide: the report's unit is inches — exactly PowerPoint's unit — so the\n// layout and every component position transfer with no conversion at all.\n// pptxgenjs is loaded lazily so it lives in its own webpack chunk.\n@Injectable()\nexport class ReportPptxService {\n\n  public async export(collected: CollectedReport): Promise<void> {\n    const PptxGenJS = (await import('pptxgenjs')).default;\n\n    const report = collected.report;\n    const pageW = report.pageWidth;\n    const pageH = report.pageHeight;\n\n    const pptx = new PptxGenJS();\n    pptx.defineLayout({ name: 'REPORT', width: pageW, height: pageH });\n    pptx.layout = 'REPORT';\n    pptx.title = report.name;\n\n    this._titleSlide(pptx, collected, pageW, pageH);\n\n    for (const collectedPage of collected.pages) {\n      const slide = pptx.addSlide();\n      const geometry = pageGeometry(report, collectedPage.page);\n\n      for (const item of collectedPage.components) {\n        this._renderComponent(pptx, slide, item, geometry.get(item.component.id));\n      }\n    }\n\n    await pptx.writeFile({ fileName: `${this._slug(report.name)}.pptx` });\n  }\n\n  private _titleSlide(pptx: any, collected: CollectedReport, pageW: number, pageH: number): void {\n    const slide = pptx.addSlide();\n\n    slide.addText(collected.report.name, {\n      x: 0.5, y: pageH * 0.3, w: pageW - 1, h: 0.8,\n      fontSize: 30, bold: true, color: '1F2933',\n    });\n\n    const lines = [\n      format(new Date(), 'MMMM d, yyyy'),\n      ...collected.filterSummary,\n    ];\n\n    slide.addText(lines.join('\\n'), {\n      x: 0.5, y: pageH * 0.3 + 0.9, w: pageW - 1, h: Math.max(0.4, lines.length * 0.25),\n      fontSize: 12, color: '52606D',\n    });\n  }\n\n  private _renderComponent(pptx: any, slide: any, item: CollectedComponent, geometry?: ComponentGeometry): void {\n    const component = item.component;\n    // Geometry is in inches — PowerPoint's native unit (flow layout arrives\n    // pre-resolved into rows by pageGeometry).\n    const { x, y, w, h } = geometry ?? component;\n\n    if (component.title) {\n      slide.addText(component.title, {\n        x, y, w, h: TITLE_H,\n        fontSize: 10, bold: true, color: '1F2933', valign: 'top',\n      });\n    }\n\n    const bodyY = y + TITLE_H;\n    const bodyH = Math.max(0.3, h - TITLE_H);\n\n    if (!item.data || !item.data.rows?.length) {\n      slide.addText(item.data ? 'No data' : 'Data unavailable', {\n        x, y: bodyY, w, h: bodyH,\n        fontSize: 10, italic: true, color: '7B8794', align: 'center', valign: 'middle',\n      });\n\n      return;\n    }\n\n    switch (component.type) {\n      case 'chart':\n        this._renderChart(pptx, slide, component, item.data, x, bodyY, w, bodyH);\n        break;\n      case 'list':\n        this._renderTable(slide, component, item.data, x, bodyY, w, bodyH);\n        break;\n      case 'kpi':\n        this._renderKpi(slide, component, item.data, x, bodyY, w, bodyH);\n        break;\n    }\n  }\n\n  private _renderChart(\n    pptx: any,\n    slide: any,\n    component: ReportComponent,\n    data: ComponentData,\n    x: number, y: number, w: number, h: number,\n  ): void {\n    const config = component.config as ChartConfig;\n    const chartType = config.chartType ?? 'bar';\n    const extracted = extractChartSeries(component, data);\n\n    const typeMap: Record<string, any> = {\n      bar: pptx.ChartType.bar,\n      line: pptx.ChartType.line,\n      area: pptx.ChartType.area,\n      pie: pptx.ChartType.pie,\n      donut: pptx.ChartType.doughnut,\n    };\n\n    const pie = chartType === 'pie' || chartType === 'donut';\n    const colorBy = isColorBy(config);\n\n    // Compact period labels match the on-screen axis (year only when the data\n    // spans years); PowerPoint can't do a styled second line, so it's inline.\n    const granularity = data.granularity;\n    const labels = granularity\n      ? extracted.categories.map((category) =>\n        formatPeriodLabel(category, granularity, spansMultipleYears(extracted.categories)))\n      : extracted.categories;\n\n    // Native chart data: one entry per series (pie charts take exactly one).\n    // colorBy emits one series per category for the on-screen overlap; PowerPoint\n    // has no equivalent overlap, so collapse them back into a single series (each\n    // category's value sits at its own slot) — one full-width bar per category —\n    // rather than letting PowerPoint cluster them into slivers.\n    const chartData = colorBy\n      ? [{\n        name: config.measures?.[0]?.label ?? config.colorBy?.label ?? '',\n        labels,\n        values: extracted.categories.map((_, index) => extracted.series[index]?.values[index] ?? 0),\n      }]\n      : (pie ? extracted.series.slice(0, 1) : extracted.series)\n        .map((series) => ({\n          name: series.name,\n          labels,\n          values: series.values.map((value) => value ?? 0),\n        }));\n\n    // A single-series colorBy chart can't carry a per-category legend in a native\n    // PowerPoint bar chart; the category axis labels identify each bar instead.\n    const legendPosition = colorBy\n      ? 'hidden'\n      : resolveLegendPosition(config, extracted.series.length);\n\n    slide.addChart(typeMap[chartType], chartData, {\n      x, y, w, h,\n      chartColors: REPORT_CHART_COLORS,\n      showLegend: legendPosition !== 'hidden',\n      legendPos: PPTX_LEGEND_POS[legendPosition],\n      legendFontSize: 9,\n      barDir: config.orientation === 'horizontal' ? 'bar' : 'col',\n      barGrouping: config.stacked ? 'stacked' : 'clustered',\n      holeSize: chartType === 'donut' ? 55 : undefined,\n      catAxisLabelFontSize: 9,\n      valAxisLabelFontSize: 9,\n      showCatAxisTitle: !!config.xAxis?.label,\n      catAxisTitle: config.xAxis?.label,\n      catAxisTitleFontSize: 10,\n      showValAxisTitle: !!config.measures?.[0]?.label && !pie,\n      valAxisTitle: config.measures?.[0]?.label,\n      valAxisTitleFontSize: 10,\n      dataBorder: { pt: 0, color: 'FFFFFF' },\n    });\n  }\n\n  private _renderTable(\n    slide: any,\n    component: ReportComponent,\n    data: ComponentData,\n    x: number, y: number, w: number, h: number,\n  ): void {\n    const config = component.config as ListConfig;\n    const columns = config.columns?.length\n      ? config.columns\n      : data.columns.map((column) => ({ column, label: column }));\n\n    const cap = Math.max(2, Math.floor(h / TABLE_ROW_H) - 1);\n    const rows = data.rows.slice(0, cap);\n    const remaining = (data.paging?.total ?? data.rows.length) - rows.length;\n\n    const header = columns.map((column) => ({\n      text: column.label || column.column,\n      options: { bold: true, color: 'FFFFFF', fill: { color: '4E79A7' } },\n    }));\n\n    const body = rows.map((row) => columns.map((column) => ({\n      text: this._cell(row[column.column], column.format),\n      options: {},\n    })));\n\n    if (remaining > 0) {\n      body.push([{\n        text: `… ${remaining} more row(s) — use the component's CSV export for the full dataset`,\n        options: { colspan: columns.length, italic: true, color: '7B8794' } as any,\n      }]);\n    }\n\n    slide.addTable([header, ...body], {\n      x, y, w,\n      fontSize: 9,\n      color: '1F2933',\n      border: { type: 'solid', pt: 0.5, color: 'E4E7EB' },\n      autoPage: false,\n      rowH: TABLE_ROW_H,\n      valign: 'middle',\n    });\n  }\n\n  private _renderKpi(\n    slide: any,\n    component: ReportComponent,\n    data: ComponentData,\n    x: number, y: number, w: number, h: number,\n  ): void {\n    const config = component.config as KpiConfig;\n    const row = data.rows[0] ?? {};\n    const column = config.measure?.column ?? Object.keys(row)[0];\n    const value = formatMeasureValue(row[column], config.measure?.format);\n\n    slide.addText([\n      { text: value, options: { fontSize: 28, bold: true, color: '1F2933', breakLine: true } },\n      { text: config.measure?.label ?? '', options: { fontSize: 10, color: '7B8794' } },\n    ], {\n      x, y, w, h,\n      align: 'center',\n      valign: 'middle',\n    });\n  }\n\n  private _cell(value: unknown, columnFormat?: string): string {\n    if (value === null || value === undefined) {\n      return '';\n    }\n\n    if (columnFormat === 'date') {\n      const date = new Date(String(value));\n\n      return Number.isNaN(date.getTime()) ? String(value) : format(date, 'MMM d, yyyy');\n    }\n\n    if (columnFormat === 'number') {\n      return formatMeasureValue(value, 'number');\n    }\n\n    return String(value);\n  }\n\n  private _slug(name: string): string {\n    return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '') || 'report';\n  }\n}\n"]}

package/esm2022/app/reports/format.mjs

@@ -0,0 +1,25 @@
+// Measure-value formatting shared by the KPI renderer and the exports — the
+// config's `format` (number | percent | currency) means the same thing on
+// screen, in PowerPoint and in PDF.
+export function formatMeasureValue(value, format) {
+    if (value === null || value === undefined || value === '') {
+        return '—';
+    }
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+        return String(value);
+    }
+    switch (format) {
+        case 'percent':
+            return `${new Intl.NumberFormat().format(numeric)}%`;
+        case 'currency':
+            return new Intl.NumberFormat(undefined, {
+                style: 'currency',
+                currency: 'USD',
+                maximumFractionDigits: 0,
+            }).format(numeric);
+        default:
+            return new Intl.NumberFormat().format(numeric);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/app/reports/interfaces/report.interface.mjs

@@ -0,0 +1,16 @@
+// The assembled report structure returned by GET /api/reports/:id — composed
+// server-side from the normalized tables (reports → report_pages →
+// report_components + report_filters, plus report_filter_groups). All keys are
+// camelCase; component `config` is the standard format the renderer maps to
+// ECharts options / FsList config.
+// The runtime Frequency control's choices — re-buckets every time-series chart
+// at view time, overriding each chart's authored granularity. 'year' reads as
+// "Annually" in the control.
+export const FREQUENCY_OPTIONS = [
+    { value: 'day', name: 'Day' },
+    { value: 'week', name: 'Week' },
+    { value: 'month', name: 'Month' },
+    { value: 'quarter', name: 'Quarter' },
+    { value: 'year', name: 'Annually' },
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report.interface.js","sourceRoot":"","sources":["../../../../../src/app/reports/interfaces/report.interface.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,mEAAmE;AACnE,+EAA+E;AAC/E,4EAA4E;AAC5E,mCAAmC;AAwFnC,+EAA+E;AAC/E,8EAA8E;AAC9E,6BAA6B;AAC7B,MAAM,CAAC,MAAM,iBAAiB,GAAgD;IAC5E,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;IAC7B,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE;IAC/B,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE;IACjC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;IACrC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE;CACpC,CAAC","sourcesContent":["// The assembled report structure returned by GET /api/reports/:id — composed\n// server-side from the normalized tables (reports → report_pages →\n// report_components + report_filters, plus report_filter_groups). All keys are\n// camelCase; component `config` is the standard format the renderer maps to\n// ECharts options / FsList config.\n\n// Layout modes: Freeform = absolutely positioned components (drag anywhere);\n// Flow = components flow like rows, each taking flowWidth % of the page width.\nexport type ReportLayout = 'freeform' | 'flow';\n\nexport interface Report {\n  id: number;\n  name: string;\n  pageSize: 'widescreen' | 'letter';\n  pageOrientation: 'landscape' | 'portrait';\n  layout: ReportLayout;\n  // IANA timezone (e.g. America/New_York) anchoring date filtering + chart date\n  // bucketing. null falls back to the account zone then UTC (resolved server-side).\n  timezone: string | null;\n  // Report-level config: typographic styles, etc. (camelCase JSON column).\n  config: ReportConfig;\n  // Canvas dimensions in INCHES (the report's native unit — PDFs and\n  // PowerPoint are inch-based, so exports are dimensionally exact).\n  pageWidth: number;\n  pageHeight: number;\n  pages: ReportPage[];\n  filterGroups: ReportFilterGroup[];\n}\n\n// Report-level styling. Sizes are in POINTS (1/72\") — the report's typography\n// maps 1:1 to PDF (72pt/in) and PowerPoint (point font sizes), so a point\n// value is dimensionally exact on screen and in every export.\nexport interface ReportConfig {\n  styles?: ReportStyles;\n}\n\nexport interface ReportStyles {\n  heading?: { size?: number };\n}\n\n// Content padding around a component's body, in INCHES (the geometry unit).\nexport interface ComponentPadding {\n  top?: number;\n  right?: number;\n  bottom?: number;\n  left?: number;\n}\n\nexport interface ReportPage {\n  id: number;\n  name: string | null;\n  order: number;\n  components: ReportComponent[];\n}\n\nexport type ReportComponentType = 'chart' | 'list' | 'kpi';\n\nexport interface ReportComponent {\n  id: number;\n  type: ReportComponentType;\n  title: string | null;\n  // Geometry in INCHES. Freeform: absolute position on the page canvas.\n  // Flow: only flowWidth/order apply; x/y are remembered for a switch back to\n  // freeform.\n  x: number;\n  y: number;\n  w: number;\n  h: number;\n  // Height mode, DERIVED from type server-side (not stored, read-only): lists\n  // and KPI tiles are auto (the box sizes to its content, `h` ignored); charts\n  // are always fixed (use `h`) so they fit the box and never overflow.\n  autoHeight: boolean;\n  // Flow layout: % of the page content width this component takes.\n  flowWidth: number;\n  // Flow layout ordering.\n  order: number;\n  sql: string | null;\n  config: ChartConfig & ListConfig & KpiConfig & ComponentLayoutConfig & Record<string, unknown>;\n  filters: ReportFilter[];\n}\n\n// Cross-type layout/style keys carried in a component's config (alongside the\n// type-specific chart/list/kpi keys).\nexport interface ComponentLayoutConfig {\n  padding?: ComponentPadding;\n}\n\n// Where a chart's legend sits relative to the plot, or 'hidden' to drop it.\nexport type LegendPosition = 'top' | 'bottom' | 'left' | 'right' | 'hidden';\n\nexport type ChartGranularity = 'day' | 'week' | 'month' | 'quarter' | 'year';\n\n// The runtime Frequency control's choices — re-buckets every time-series chart\n// at view time, overriding each chart's authored granularity. 'year' reads as\n// \"Annually\" in the control.\nexport const FREQUENCY_OPTIONS: { value: ChartGranularity; name: string }[] = [\n  { value: 'day', name: 'Day' },\n  { value: 'week', name: 'Week' },\n  { value: 'month', name: 'Month' },\n  { value: 'quarter', name: 'Quarter' },\n  { value: 'year', name: 'Annually' },\n];\n\nexport interface ChartConfig {\n  chartType?: 'bar' | 'line' | 'area' | 'pie' | 'donut';\n  // For kind 'time', the server buckets the raw datetime column to `granularity`\n  // in the report's timezone (the SQL exposes the raw column, unbucketed).\n  xAxis?: { column: string; kind?: 'category' | 'time'; granularity?: ChartGranularity; label?: string };\n  measures?: ChartMeasure[];\n  splitBy?: { column: string; label?: string };\n  // Single-dimension bar charts only: color each bar by its own category and\n  // show a legend, WITHOUT splitting into multiple series (which slivers the\n  // bars). v1 expects colorBy.column === xAxis.column. Ignored when splitBy is\n  // set or the chart isn't a bar chart.\n  colorBy?: { column: string; label?: string };\n  orientation?: 'vertical' | 'horizontal';\n  stacked?: boolean;\n  legend?: LegendPosition;\n  sort?: ReportSort;\n  limit?: number;\n}\n\nexport interface ChartMeasure {\n  column: string;\n  aggregation?: 'sum' | 'count' | 'avg' | 'min' | 'max';\n  label?: string;\n  format?: 'number' | 'percent' | 'currency';\n}\n\nexport interface ListConfig {\n  columns?: { column: string; label?: string; format?: 'date' | 'number' }[];\n  sort?: ReportSort;\n  pageSize?: number;\n}\n\nexport interface KpiConfig {\n  measure?: ChartMeasure;\n}\n\nexport interface ReportSort {\n  column: string;\n  direction?: 'asc' | 'desc';\n}\n\nexport type ReportFilterType = 'dateRange' | 'select' | 'keyword';\n\n// Where a filter group's control is exposed. A group can be shown on its\n// components, in the report bar, or BOTH at once (the two are independent\n// toggles in the UI); a column with neither exposed simply has no filter.\nexport type ReportFilterLevel = 'component' | 'report' | 'both';\n\n// One filterable output column of a component's SQL, with the filter interface\n// INFERRED from its data (the human never picks the interface — it follows the\n// column's type). Drives the Filters tab listing.\nexport interface ReportFilterableColumn {\n  column: string;\n  type: ReportFilterType;\n}\n\n// Ground truth: one filterable output column ON one component's SQL. Always a\n// member of a filter group — the unit that links equivalent filters across\n// components and decides where the control renders (component vs report bar).\nexport interface ReportFilter {\n  id: number;\n  componentId: number;\n  filterGroupId: number;\n  filterColumn: string;\n  label: string | null;\n  enabled: boolean;\n  hasOptions: boolean;\n  config: Record<string, unknown>;\n}\n\nexport interface ReportFilterGroup {\n  id: number;\n  label: string | null;\n  type: ReportFilterType;\n  level: ReportFilterLevel;\n  order: number;\n  config: { default?: FilterGroupDefault } & Record<string, unknown>;\n  filters: ReportFilter[];\n}\n\nexport interface FilterGroupDefault {\n  relative?: string; // e.g. last12Months, last30Days, yearToDate\n  start?: string;\n  end?: string;\n}\n\n// The session value of a filter group (never persisted): shape depends on the\n// group's type.\nexport interface FilterGroupValue {\n  start?: Date | string | null; // dateRange\n  end?: Date | string | null; // dateRange\n  values?: unknown[]; // select\n  value?: string; // keyword\n}\n\n// One resolved filter sent with a component's data request.\nexport interface ResolvedFilterValue {\n  filterId: number;\n  start?: string;\n  end?: string;\n  values?: unknown[];\n  value?: string;\n}\n\n// Per-component interaction state sent with the data request: lists send\n// sort/paging; time-series charts send the viewer's chosen Frequency, which\n// overrides the authored granularity for that request only.\nexport interface ComponentDataState {\n  sort?: ReportSort;\n  page?: number;\n  pageSize?: number;\n  frequency?: ChartGranularity;\n}\n\nexport interface ComponentData {\n  columns: string[];\n  rows: Record<string, unknown>[];\n  paging?: { total: number; page: number; pageSize: number };\n  truncated: boolean;\n  // The effective time bucket the rows were grouped into (after any Frequency\n  // override), or null for a non-time axis. Drives the compact x-axis labels.\n  granularity?: ChartGranularity | null;\n}\n\nexport interface ReportListItem {\n  id: number;\n  name: string;\n}\n\n// The chat turn flags this context's backend adds (Reports\\AiView).\nexport interface ReportChatResponse {\n  reportChanged?: boolean;\n  reportRenamed?: boolean;\n}\n"]}

package/esm2022/app/reports/layout.mjs

@@ -0,0 +1,50 @@
+// Page padding for flow layout, inches — mirrored by the canvas CSS.
+export const FLOW_PADDING = 0.25;
+// Default content padding around a component's body, inches (1/8").
+export const DEFAULT_COMPONENT_PADDING = 0.125;
+// Default report heading size, points (1/72"). Applies to component titles.
+export const DEFAULT_HEADING_SIZE = 16;
+// Resolved geometry (inches) for every component on a page, in BOTH layout
+// modes — the single definition the PPT and PDF exports lay out from:
+//
+//   Freeform: the stored x/y/w/h verbatim.
+//   Flow:     components in `order`, each flowWidth% of the content width,
+//             wrapping into rows (a row breaks when the next component would
+//             exceed 100%); row height = the tallest component in the row.
+//             Matches the canvas's flex-wrap rendering.
+export function pageGeometry(report, page) {
+    const geometry = new Map();
+    if (report.layout !== 'flow') {
+        for (const component of page.components) {
+            geometry.set(component.id, {
+                x: component.x, y: component.y, w: component.w, h: component.h,
+            });
+        }
+        return geometry;
+    }
+    const contentW = report.pageWidth - FLOW_PADDING * 2;
+    const sorted = [...page.components].sort((a, b) => (a.order - b.order) || (a.y - b.y) || (a.x - b.x));
+    let cursorX = 0; // fraction of contentW consumed in the current row
+    let rowTop = FLOW_PADDING;
+    let rowHeight = 0;
+    for (const component of sorted) {
+        const fraction = Math.min(100, Math.max(10, component.flowWidth ?? 50)) / 100;
+        // Wrap when this component doesn't fit the remainder (small tolerance for
+        // 33.33+33.33+33.33 style splits).
+        if (cursorX + fraction > 1.001) {
+            rowTop += rowHeight;
+            cursorX = 0;
+            rowHeight = 0;
+        }
+        geometry.set(component.id, {
+            x: FLOW_PADDING + cursorX * contentW,
+            y: rowTop,
+            w: fraction * contentW,
+            h: component.h,
+        });
+        cursorX += fraction;
+        rowHeight = Math.max(rowHeight, component.h);
+    }
+    return geometry;
+}
+//# sourceMappingURL=data:application/json;base64,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