@ministryofjustice/hmpps-digital-prison-reporting-frontend 4.28.7 → 4.29.0

package/dpr/utils/TemplateBuilder/ParentChildDataBuilder/ParentChildDataBuilder.ts

@@ -0,0 +1,203 @@
+import { components } from '../../../types/api'
+import DataTableBuilder from '../../DataTableBuilder/DataTableBuilder'
+import { DataTable } from '../../DataTableBuilder/types'
+import { SectionedDataHelper } from '../SectionedDataHelper/SectionedDataHelper'
+import { ReportTemplateData, SectionData } from '../SectionedDataHelper/types'
+import { TemplateBuilder } from '../TemplateBuilder'
+import { ChildData, GroupedParentChildDataset, ParentChildTableData, ParentChildDataset } from './types'
+
+export class ParentChildDataBuilder extends TemplateBuilder {
+  childColumns: Array<string> = []
+
+  childVariants: components['schemas']['ChildVariantDefinition'][] = []
+
+  childData: Array<ChildData> = []
+
+  joinFields: Array<components['schemas']['FieldDefinition']> = []
+
+  childFields: Array<components['schemas']['FieldDefinition']> = []
+
+  parentChildDatasets: ParentChildDataset[] = []
+
+  dataTableBuilder!: DataTableBuilder
+
+  constructor(variant: components['schemas']['VariantDefinition']) {
+    super(variant)
+
+    this.childVariants = this.variant.childVariants || []
+  }
+
+  getChildVariant(childId: string) {
+    return this.childVariants.find((cv) => cv.id === childId)
+  }
+
+  /**
+   * Exracts the relevant data from the child variant definition
+   * to generate the child table
+   *
+   * @param {string} childId
+   * @return { fields: components['schemas']['FieldDefinition'][], joinFields: string[], columns: string[], name: string }
+   * @memberof ParentChildDataBuilder
+   */
+  getChildVariantDefinitionData(childId: string) {
+    const childVariant = this.getChildVariant(childId)
+
+    let fields: components['schemas']['FieldDefinition'][] = []
+    let joinFields: string[] = []
+    let columns: string[] = []
+    let name = 'Child report'
+
+    if (childVariant && childVariant.specification) {
+      fields = childVariant.specification.fields
+      joinFields = childVariant && childVariant.specification ? childVariant.joinFields : []
+      columns = fields.filter((f) => f.visible).map((f) => f.name)
+      name = childVariant.name
+    }
+
+    return {
+      fields,
+      joinFields,
+      columns,
+      name,
+    }
+  }
+
+  /**
+   * Maps the parent child rows.
+   * Splits into sections that will become the parent table
+   *
+   * @return {*}  {GroupedParentChildDataset[]}
+   * @memberof ParentChildDataBuilder
+   */
+  mergeParentChildAndGroup(parentData: Record<string, string>[]): GroupedParentChildDataset[] {
+    const groups: GroupedParentChildDataset[] = []
+    let pendingParents: Array<Record<string, string>> = []
+
+    parentData.forEach((parentRow) => {
+      // Build a dataset for this parent
+      const dataset: ParentChildDataset = {
+        parent: parentRow,
+        children: [],
+      }
+
+      // Match against each child dataset
+      this.childData.forEach((child) => {
+        const { joinFields } = this.getChildVariantDefinitionData(child.id)
+        const matchedChildren: Record<string, string>[] = []
+
+        // Compare join fields
+        child.data.forEach((childRow) => {
+          const isMatch = joinFields.every((col) => {
+            return parentRow[col] === childRow[col]
+          })
+          if (isMatch) matchedChildren.push(childRow)
+        })
+
+        if (matchedChildren.length) {
+          dataset.children.push({
+            id: child.id,
+            data: matchedChildren,
+          })
+        }
+      })
+
+      // Always collect the parent
+      pendingParents.push(dataset.parent)
+
+      // If dataset has children → close the group
+      if (dataset.children.length > 0) {
+        groups.push({
+          parent: pendingParents,
+          children: dataset.children,
+        })
+        pendingParents = []
+      }
+    })
+
+    // If leftover parents exist, make a final group (empty children)
+    if (pendingParents.length > 0) {
+      groups.push({
+        parent: pendingParents,
+        children: [],
+      })
+    }
+
+    return groups
+  }
+
+  /**
+   * Maps the parent child data to a table data
+   *
+   * @param {GroupedParentChildDataset[]} parentChildGroups
+   * @return {*}  {ParentChildData[]}
+   * @memberof ParentChildDataBuilder
+   */
+  mapToTableData(parentChildGroups: GroupedParentChildDataset[]): ParentChildTableData[] {
+    const parentTableBuilder = new DataTableBuilder(this.fields)
+    return parentChildGroups.map((group: GroupedParentChildDataset) => {
+      const parentTable = parentTableBuilder.withNoHeaderOptions(this.columns).buildTable(group.parent)
+      const children: ParentChildTableData['children'] = this.mapChildDataToTableData(group)
+
+      return {
+        parent: parentTable,
+        children,
+      }
+    })
+  }
+
+  /**
+   * Maps the grouped child data to table data
+   *
+   * @param {GroupedParentChildDataset} group
+   * @return {*}
+   * @memberof ParentChildDataBuilder
+   */
+  mapChildDataToTableData(group: GroupedParentChildDataset) {
+    return group.children.map((child) => {
+      const { fields: childFields, columns: childColumns, name } = this.getChildVariantDefinitionData(child.id)
+      const childTableBuilder = new DataTableBuilder(childFields)
+      const childTable = childTableBuilder.withNoHeaderOptions(childColumns).buildTable(child.data)
+
+      return {
+        title: name,
+        ...childTable,
+      }
+    })
+  }
+
+  withChildData(childData: Array<ChildData>) {
+    this.childData = childData
+    return this
+  }
+
+  withChildColumns(childColumns: string[]) {
+    this.childColumns = childColumns
+    return this
+  }
+
+  build(): ReportTemplateData {
+    const sectionData = new SectionedDataHelper()
+      .withSections(this.sections)
+      .withData(this.data)
+      .withFields(this.fields)
+      .withReportQuery(this.reportQuery)
+      .build()
+
+    const { sections } = sectionData
+    const mappedSections = sections.map((section: SectionData) => {
+      const groups = this.mergeParentChildAndGroup(<Array<Record<string, string>>>section.data)
+      const table = this.mapToTableData(groups)
+
+      return {
+        ...section,
+        summaries: [] as unknown as Record<string, DataTable[]>,
+        data: table,
+      }
+    })
+
+    return {
+      rowCount: this.data.length,
+      sections: mappedSections,
+    }
+  }
+}

package/dpr/utils/TemplateBuilder/ParentChildDataBuilder/types.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../dpr/utils/TemplateBuilder/ParentChildDataBuilder/types.d.ts"],
+  "sourcesContent": ["import { Cell } from '../../DataTableBuilder/types'\n\nexport interface ChildData {\n  id: string\n  data: Array<Record<string, string>>\n}\n\nexport interface ParentChildTableData {\n  parent: {\n    head: Cell[] | null\n    rows: Cell[][]\n  }\n  children: {\n    title: string\n    head: Cell[] | null\n    rows: Cell[][]\n  }[]\n}\n\nexport interface ParentChildDataset {\n  parent: Record<string, string>\n  children: ChildData[]\n}\n\nexport interface GroupedParentChildDataset {\n  parent: Array<Record<string, string>>\n  children: ChildData[]\n}\nexport interface ParentChildTemplateData {\n  rowCount: number\n  sections: {\n    title?: string\n    count?: number\n    data: ParentChildTableData[]\n  }[]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dpr/utils/TemplateBuilder/ParentChildDataBuilder/types.d.ts

@@ -0,0 +1,36 @@
+import { Cell } from '../../DataTableBuilder/types'
+
+export interface ChildData {
+  id: string
+  data: Array<Record<string, string>>
+}
+
+export interface ParentChildTableData {
+  parent: {
+    head: Cell[] | null
+    rows: Cell[][]
+  }
+  children: {
+    title: string
+    head: Cell[] | null
+    rows: Cell[][]
+  }[]
+}
+
+export interface ParentChildDataset {
+  parent: Record<string, string>
+  children: ChildData[]
+}
+
+export interface GroupedParentChildDataset {
+  parent: Array<Record<string, string>>
+  children: ChildData[]
+}
+export interface ParentChildTemplateData {
+  rowCount: number
+  sections: {
+    title?: string
+    count?: number
+    data: ParentChildTableData[]
+  }[]
+}

package/dpr/utils/TemplateBuilder/ReportBuilder/ReportBuilder.js

@@ -0,0 +1,114 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ReportBuilder_exports = {};
+__export(ReportBuilder_exports, {
+  ReportBuilder: () => ReportBuilder
+});
+module.exports = __toCommonJS(ReportBuilder_exports);
+var import_SummaryDataHelper = require("../SummaryDataHelper/SummaryDataHelper");
+var import_DataTableBuilder = __toESM(require("../../DataTableBuilder/DataTableBuilder"));
+var import_SectionedDataHelper = require("../SectionedDataHelper/SectionedDataHelper");
+var import_TemplateBuilder = require("../TemplateBuilder");
+class ReportBuilder extends import_TemplateBuilder.TemplateBuilder {
+  dataTableBuilder;
+  sectionBuilder;
+  constructor(variant) {
+    super(variant);
+  }
+  buildMainTable(section) {
+    const collatedSummaryBuilder = new import_SummaryDataHelper.CollatedSummaryBuilder(this.specification, section.summaries);
+    const tableSummaries = collatedSummaryBuilder.collateDataTableSummaries();
+    this.dataTableBuilder = new import_DataTableBuilder.default(this.fields);
+    return this.dataTableBuilder.withSummaries(tableSummaries).withHeaderOptions({
+      columns: this.columns,
+      reportQuery: this.reportQuery,
+      interactive: Boolean(this.interactive)
+    }).buildTable(section.data);
+  }
+  buildSummaryTables(summaries) {
+    const summaryTables = summaries.map((summaryData) => {
+      const fields = summaryData.fields;
+      const { data, template } = summaryData;
+      const summaryTableData = new import_DataTableBuilder.default(fields).withNoHeaderOptions(fields.map((f) => f.name)).buildTable(data);
+      return {
+        template,
+        data: summaryTableData
+      };
+    });
+    return this.groupSummaryTables(summaryTables);
+  }
+  buildSummariesTables(section) {
+    const { summaries } = section;
+    const summaryTables = summaries.map((summaryData) => {
+      const fields = summaryData.fields;
+      const { data, template } = summaryData;
+      const summaryTableData = new import_DataTableBuilder.default(fields).withNoHeaderOptions(fields.map((f) => f.name)).buildTable(data);
+      return {
+        template,
+        data: summaryTableData
+      };
+    });
+    return this.groupSummaryTables(summaryTables);
+  }
+  groupSummaryTables(summaryTables) {
+    return summaryTables.reduce((acc, item) => {
+      if (!acc[item.template]) {
+        acc[item.template] = [];
+      }
+      acc[item.template].push(item.data);
+      return acc;
+    }, {});
+  }
+  buildSectionedData() {
+    const sectionData = new import_SectionedDataHelper.SectionedDataHelper().withData(this.data).withSections(this.sections).withSummaries(this.summaries).withFields(this.fields).withReportQuery(this.reportQuery).build();
+    return sectionData.sections.map((section) => {
+      const tableData = this.buildMainTable(section);
+      const sectionSummaryTables = this.buildSummaryTables(section.summaries);
+      return {
+        ...section,
+        summaries: sectionSummaryTables,
+        data: tableData
+      };
+    });
+  }
+  build() {
+    const pageSummaryTables = this.buildSummaryTables(this.pageSummaries);
+    const sections = this.buildSectionedData();
+    return {
+      rowCount: this.data.length,
+      summaries: pageSummaryTables,
+      sections
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReportBuilder
+});
+//# sourceMappingURL=ReportBuilder.js.map

package/dpr/utils/TemplateBuilder/ReportBuilder/ReportBuilder.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../dpr/utils/TemplateBuilder/ReportBuilder/ReportBuilder.ts"],
+  "sourcesContent": ["import { AsyncSummary } from '../../../types/UserReports'\nimport { SummaryTemplate } from '../../../types/Templates'\nimport { components } from '../../../types/api'\nimport { CollatedSummaryBuilder } from '../SummaryDataHelper/SummaryDataHelper'\nimport DataTableBuilder from '../../DataTableBuilder/DataTableBuilder'\nimport { SectionedDataHelper } from '../SectionedDataHelper/SectionedDataHelper'\nimport { ReportTemplateData, SectionData } from '../SectionedDataHelper/types'\nimport { DataTable } from '../../DataTableBuilder/types'\nimport { TemplateBuilder } from '../TemplateBuilder'\n\nexport class ReportBuilder extends TemplateBuilder {\n  dataTableBuilder!: DataTableBuilder\n\n  sectionBuilder!: SectionedDataHelper\n\n  constructor(variant: components['schemas']['VariantDefinition']) {\n    super(variant)\n  }\n\n  buildMainTable(section: SectionData) {\n    const collatedSummaryBuilder = new CollatedSummaryBuilder(this.specification, section.summaries)\n    const tableSummaries = collatedSummaryBuilder.collateDataTableSummaries()\n    this.dataTableBuilder = new DataTableBuilder(this.fields)\n    return this.dataTableBuilder\n      .withSummaries(tableSummaries)\n      .withHeaderOptions({\n        columns: this.columns,\n        reportQuery: this.reportQuery,\n        interactive: Boolean(this.interactive),\n      })\n      .buildTable(section.data)\n  }\n\n  buildSummaryTables(summaries: AsyncSummary[]) {\n    const summaryTables = summaries.map((summaryData) => {\n      const fields = <components['schemas']['FieldDefinition'][]>summaryData.fields\n      const { data, template } = summaryData\n      const summaryTableData = new DataTableBuilder(fields)\n        .withNoHeaderOptions(fields.map((f) => f.name))\n        .buildTable(data)\n\n      return {\n        template,\n        data: summaryTableData,\n      }\n    })\n\n    return this.groupSummaryTables(summaryTables)\n  }\n\n  buildSummariesTables(section: SectionData) {\n    const { summaries } = section\n    const summaryTables: {\n      template: SummaryTemplate\n      data: DataTable\n    }[] = summaries.map((summaryData) => {\n      const fields = <components['schemas']['FieldDefinition'][]>summaryData.fields\n      const { data, template } = summaryData\n      const summaryTableData = new DataTableBuilder(fields)\n        .withNoHeaderOptions(fields.map((f) => f.name))\n        .buildTable(data)\n\n      return {\n        template,\n        data: summaryTableData,\n      }\n    })\n\n    return this.groupSummaryTables(summaryTables)\n  }\n\n  groupSummaryTables(\n    summaryTables: {\n      template: SummaryTemplate\n      data: DataTable\n    }[],\n  ) {\n    return summaryTables.reduce<Record<string, DataTable[]>>((acc, item) => {\n      if (!acc[item.template]) {\n        acc[item.template] = []\n      }\n      acc[item.template].push(item.data)\n      return acc\n    }, {})\n  }\n\n  buildSectionedData() {\n    const sectionData = new SectionedDataHelper()\n      .withData(this.data)\n      .withSections(this.sections)\n      .withSummaries(this.summaries)\n      .withFields(this.fields)\n      .withReportQuery(this.reportQuery)\n      .build()\n\n    return sectionData.sections.map((section: SectionData) => {\n      const tableData = this.buildMainTable(section)\n      const sectionSummaryTables = this.buildSummaryTables(section.summaries)\n      return {\n        ...section,\n        summaries: sectionSummaryTables,\n        data: tableData,\n      }\n    })\n  }\n\n  build(): ReportTemplateData {\n    const pageSummaryTables = this.buildSummaryTables(this.pageSummaries)\n    const sections = this.buildSectionedData()\n\n    return {\n      rowCount: this.data.length,\n      summaries: pageSummaryTables,\n      sections,\n    }\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,+BAAuC;AACvC,8BAA6B;AAC7B,iCAAoC;AAGpC,6BAAgC;AAEzB,MAAM,sBAAsB,uCAAgB;AAAA,EACjD;AAAA,EAEA;AAAA,EAEA,YAAY,SAAqD;AAC/D,UAAM,OAAO;AAAA,EACf;AAAA,EAEA,eAAe,SAAsB;AACnC,UAAM,yBAAyB,IAAI,gDAAuB,KAAK,eAAe,QAAQ,SAAS;AAC/F,UAAM,iBAAiB,uBAAuB,0BAA0B;AACxE,SAAK,mBAAmB,IAAI,wBAAAA,QAAiB,KAAK,MAAM;AACxD,WAAO,KAAK,iBACT,cAAc,cAAc,EAC5B,kBAAkB;AAAA,MACjB,SAAS,KAAK;AAAA,MACd,aAAa,KAAK;AAAA,MAClB,aAAa,QAAQ,KAAK,WAAW;AAAA,IACvC,CAAC,EACA,WAAW,QAAQ,IAAI;AAAA,EAC5B;AAAA,EAEA,mBAAmB,WAA2B;AAC5C,UAAM,gBAAgB,UAAU,IAAI,CAAC,gBAAgB;AACnD,YAAM,SAAqD,YAAY;AACvE,YAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,YAAM,mBAAmB,IAAI,wBAAAA,QAAiB,MAAM,EACjD,oBAAoB,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAC7C,WAAW,IAAI;AAElB,aAAO;AAAA,QACL;AAAA,QACA,MAAM;AAAA,MACR;AAAA,IACF,CAAC;AAED,WAAO,KAAK,mBAAmB,aAAa;AAAA,EAC9C;AAAA,EAEA,qBAAqB,SAAsB;AACzC,UAAM,EAAE,UAAU,IAAI;AACtB,UAAM,gBAGA,UAAU,IAAI,CAAC,gBAAgB;AACnC,YAAM,SAAqD,YAAY;AACvE,YAAM,EAAE,MAAM,SAAS,IAAI;AAC3B,YAAM,mBAAmB,IAAI,wBAAAA,QAAiB,MAAM,EACjD,oBAAoB,OAAO,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAC7C,WAAW,IAAI;AAElB,aAAO;AAAA,QACL;AAAA,QACA,MAAM;AAAA,MACR;AAAA,IACF,CAAC;AAED,WAAO,KAAK,mBAAmB,aAAa;AAAA,EAC9C;AAAA,EAEA,mBACE,eAIA;AACA,WAAO,cAAc,OAAoC,CAAC,KAAK,SAAS;AACtE,UAAI,CAAC,IAAI,KAAK,QAAQ,GAAG;AACvB,YAAI,KAAK,QAAQ,IAAI,CAAC;AAAA,MACxB;AACA,UAAI,KAAK,QAAQ,EAAE,KAAK,KAAK,IAAI;AACjC,aAAO;AAAA,IACT,GAAG,CAAC,CAAC;AAAA,EACP;AAAA,EAEA,qBAAqB;AACnB,UAAM,cAAc,IAAI,+CAAoB,EACzC,SAAS,KAAK,IAAI,EAClB,aAAa,KAAK,QAAQ,EAC1B,cAAc,KAAK,SAAS,EAC5B,WAAW,KAAK,MAAM,EACtB,gBAAgB,KAAK,WAAW,EAChC,MAAM;AAET,WAAO,YAAY,SAAS,IAAI,CAAC,YAAyB;AACxD,YAAM,YAAY,KAAK,eAAe,OAAO;AAC7C,YAAM,uBAAuB,KAAK,mBAAmB,QAAQ,SAAS;AACtE,aAAO;AAAA,QACL,GAAG;AAAA,QACH,WAAW;AAAA,QACX,MAAM;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,QAA4B;AAC1B,UAAM,oBAAoB,KAAK,mBAAmB,KAAK,aAAa;AACpE,UAAM,WAAW,KAAK,mBAAmB;AAEzC,WAAO;AAAA,MACL,UAAU,KAAK,KAAK;AAAA,MACpB,WAAW;AAAA,MACX;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": ["DataTableBuilder"]
+}

package/dpr/utils/TemplateBuilder/ReportBuilder/ReportBuilder.ts

@@ -0,0 +1,117 @@
+import { AsyncSummary } from '../../../types/UserReports'
+import { SummaryTemplate } from '../../../types/Templates'
+import { components } from '../../../types/api'
+import { CollatedSummaryBuilder } from '../SummaryDataHelper/SummaryDataHelper'
+import DataTableBuilder from '../../DataTableBuilder/DataTableBuilder'
+import { SectionedDataHelper } from '../SectionedDataHelper/SectionedDataHelper'
+import { ReportTemplateData, SectionData } from '../SectionedDataHelper/types'
+import { DataTable } from '../../DataTableBuilder/types'
+import { TemplateBuilder } from '../TemplateBuilder'
+
+export class ReportBuilder extends TemplateBuilder {
+  dataTableBuilder!: DataTableBuilder
+
+  sectionBuilder!: SectionedDataHelper
+
+  constructor(variant: components['schemas']['VariantDefinition']) {
+    super(variant)
+  }
+
+  buildMainTable(section: SectionData) {
+    const collatedSummaryBuilder = new CollatedSummaryBuilder(this.specification, section.summaries)
+    const tableSummaries = collatedSummaryBuilder.collateDataTableSummaries()
+    this.dataTableBuilder = new DataTableBuilder(this.fields)
+    return this.dataTableBuilder
+      .withSummaries(tableSummaries)
+      .withHeaderOptions({
+        columns: this.columns,
+        reportQuery: this.reportQuery,
+        interactive: Boolean(this.interactive),
+      })
+      .buildTable(section.data)
+  }
+
+  buildSummaryTables(summaries: AsyncSummary[]) {
+    const summaryTables = summaries.map((summaryData) => {
+      const fields = <components['schemas']['FieldDefinition'][]>summaryData.fields
+      const { data, template } = summaryData
+      const summaryTableData = new DataTableBuilder(fields)
+        .withNoHeaderOptions(fields.map((f) => f.name))
+        .buildTable(data)
+
+      return {
+        template,
+        data: summaryTableData,
+      }
+    })
+
+    return this.groupSummaryTables(summaryTables)
+  }
+
+  buildSummariesTables(section: SectionData) {
+    const { summaries } = section
+    const summaryTables: {
+      template: SummaryTemplate
+      data: DataTable
+    }[] = summaries.map((summaryData) => {
+      const fields = <components['schemas']['FieldDefinition'][]>summaryData.fields
+      const { data, template } = summaryData
+      const summaryTableData = new DataTableBuilder(fields)
+        .withNoHeaderOptions(fields.map((f) => f.name))
+        .buildTable(data)
+
+      return {
+        template,
+        data: summaryTableData,
+      }
+    })
+
+    return this.groupSummaryTables(summaryTables)
+  }
+
+  groupSummaryTables(
+    summaryTables: {
+      template: SummaryTemplate
+      data: DataTable
+    }[],
+  ) {
+    return summaryTables.reduce<Record<string, DataTable[]>>((acc, item) => {
+      if (!acc[item.template]) {
+        acc[item.template] = []
+      }
+      acc[item.template].push(item.data)
+      return acc
+    }, {})
+  }
+
+  buildSectionedData() {
+    const sectionData = new SectionedDataHelper()
+      .withData(this.data)
+      .withSections(this.sections)
+      .withSummaries(this.summaries)
+      .withFields(this.fields)
+      .withReportQuery(this.reportQuery)
+      .build()
+
+    return sectionData.sections.map((section: SectionData) => {
+      const tableData = this.buildMainTable(section)
+      const sectionSummaryTables = this.buildSummaryTables(section.summaries)
+      return {
+        ...section,
+        summaries: sectionSummaryTables,
+        data: tableData,
+      }
+    })
+  }
+
+  build(): ReportTemplateData {
+    const pageSummaryTables = this.buildSummaryTables(this.pageSummaries)
+    const sections = this.buildSectionedData()
+
+    return {
+      rowCount: this.data.length,
+      summaries: pageSummaryTables,
+      sections,
+    }
+  }
+}

package/dpr/utils/TemplateBuilder/ReportBuilder/types.d.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../dpr/utils/TemplateBuilder/ReportBuilder/types.d.ts"],
+  "sourcesContent": ["import { Cell } from '../../DataTableBuilder/types'\n\nexport interface ListSectionTableData {\n  head: Cell[] | null\n  rows: Cell[][]\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}

package/dpr/utils/TemplateBuilder/ReportBuilder/types.d.ts

@@ -0,0 +1,6 @@
+import { Cell } from '../../DataTableBuilder/types'
+
+export interface ListSectionTableData {
+  head: Cell[] | null
+  rows: Cell[][]
+}