@harbortouch/skytab-analytics-report-utils 0.18.0 → 0.20.0

package/dist/exporters/exportBuilder.d.cts

@@ -0,0 +1,56 @@
+import { R as ReportType, A as AnalyticsField } from '../report-BOL9p86o.cjs';
+import { E as ExportTable, a as ExportFilter } from '../types-BzLsgnfc.cjs';
+
+interface ReportDocumentSection {
+    sheetName: string;
+    table?: ExportTable;
+    filters?: ExportFilter[];
+}
+interface ReportLocation {
+    id: number;
+    name: string;
+    timezone: string;
+    language: string;
+    currency: string;
+    countryCode: string;
+    merchantId: string;
+}
+interface ReportParameters {
+    compareToLastWeek?: boolean;
+    compareToLastYear?: boolean;
+    cols?: string[];
+    secondGroupBy?: AnalyticsField;
+    startDate: string | Date;
+    endDate: string | Date;
+    groupBy?: AnalyticsField;
+    order?: string;
+}
+type ReportData = SingleReportData | Record<string, SingleReportData>;
+type SingleReportData = Record<string, unknown>[];
+declare class ExportBuilder {
+    private readonly reportType;
+    private readonly locations;
+    private readonly locale;
+    constructor(reportType: ReportType, locations: ReportLocation[], locale: string);
+    private getFormattingConfig;
+    private getConfig;
+    private getConfigSectionName;
+    private translate;
+    private buildColumnPrefix;
+    private sortAndPrependPrefix;
+    private resolveColumns;
+    private getColumnHeader;
+    private resolveColumnsAndHeaders;
+    private formatField;
+    private formatRow;
+    private resolveLabelField;
+    private buildTotalsRow;
+    private getExtraFooterRows;
+    private renderTableContent;
+    private getDataForConfig;
+    private formatMaybeDate;
+    private buildMetadata;
+    getContent(reportData: ReportData, parameters: ReportParameters, name: string): ReportDocumentSection[];
+}
+
+export { ExportBuilder, type ReportData, type ReportDocumentSection, type ReportLocation, type ReportParameters, type SingleReportData };

package/dist/exporters/exportBuilder.d.ts

@@ -0,0 +1,56 @@
+import { R as ReportType, A as AnalyticsField } from '../report-BOL9p86o.js';
+import { E as ExportTable, a as ExportFilter } from '../types-BzLsgnfc.js';
+
+interface ReportDocumentSection {
+    sheetName: string;
+    table?: ExportTable;
+    filters?: ExportFilter[];
+}
+interface ReportLocation {
+    id: number;
+    name: string;
+    timezone: string;
+    language: string;
+    currency: string;
+    countryCode: string;
+    merchantId: string;
+}
+interface ReportParameters {
+    compareToLastWeek?: boolean;
+    compareToLastYear?: boolean;
+    cols?: string[];
+    secondGroupBy?: AnalyticsField;
+    startDate: string | Date;
+    endDate: string | Date;
+    groupBy?: AnalyticsField;
+    order?: string;
+}
+type ReportData = SingleReportData | Record<string, SingleReportData>;
+type SingleReportData = Record<string, unknown>[];
+declare class ExportBuilder {
+    private readonly reportType;
+    private readonly locations;
+    private readonly locale;
+    constructor(reportType: ReportType, locations: ReportLocation[], locale: string);
+    private getFormattingConfig;
+    private getConfig;
+    private getConfigSectionName;
+    private translate;
+    private buildColumnPrefix;
+    private sortAndPrependPrefix;
+    private resolveColumns;
+    private getColumnHeader;
+    private resolveColumnsAndHeaders;
+    private formatField;
+    private formatRow;
+    private resolveLabelField;
+    private buildTotalsRow;
+    private getExtraFooterRows;
+    private renderTableContent;
+    private getDataForConfig;
+    private formatMaybeDate;
+    private buildMetadata;
+    getContent(reportData: ReportData, parameters: ReportParameters, name: string): ReportDocumentSection[];
+}
+
+export { ExportBuilder, type ReportData, type ReportDocumentSection, type ReportLocation, type ReportParameters, type SingleReportData };

package/dist/exporters/exportBuilder.js

@@ -0,0 +1,246 @@
+import {
+  calculateReportTotals,
+  en_US_default,
+  formatFieldValue,
+  getColumnExportHeaderLabel,
+  getColumnMetadata,
+  getReportConfig,
+  getReportFormattingLocaleOptions,
+  resolveTranslate
+} from "../chunk-7NXZJEGU.js";
+
+// src/exporters/exportBuilder.ts
+import { format, isValid, parseISO } from "date-fns";
+var ExportBuilder = class {
+  constructor(reportType, locations, locale) {
+    this.reportType = reportType;
+    this.locations = locations;
+    this.locale = locale;
+  }
+  getFormattingConfig() {
+    const configs = getReportFormattingLocaleOptions(this.locations);
+    return configs[0];
+  }
+  getConfig() {
+    return getReportConfig(this.reportType);
+  }
+  getConfigSectionName(config) {
+    return config.sectionName ? this.translate(config.sectionName) : "Unknown section";
+  }
+  translate(messageKey) {
+    return resolveTranslate(messageKey, this.locale);
+  }
+  buildColumnPrefix(config, parameters) {
+    const prefix = [];
+    if ("groupByName" in config.fields) {
+      prefix.push("groupByName");
+    }
+    if (parameters.secondGroupBy && "groupByName2" in config.fields) {
+      prefix.push("groupByName2");
+    }
+    return prefix;
+  }
+  sortAndPrependPrefix(config, parameters, collected) {
+    const orderMap = new Map(config.availableColumns.map((col, i) => [col, i]));
+    const sorted = [...collected].sort((a, b) => (orderMap.get(a) ?? Infinity) - (orderMap.get(b) ?? Infinity));
+    return [...this.buildColumnPrefix(config, parameters), ...sorted];
+  }
+  resolveColumns(config, parameters) {
+    const selectedGroupIds = Array.isArray(parameters.cols) ? parameters.cols : null;
+    const compareToLastWeek = parameters.compareToLastWeek === true;
+    const compareToLastYear = parameters.compareToLastYear === true;
+    if (selectedGroupIds !== null && selectedGroupIds.length === 0) {
+      return this.buildColumnPrefix(config, parameters);
+    }
+    if (selectedGroupIds?.length && config.columnGroups?.length) {
+      const collected = [];
+      for (const groupId of selectedGroupIds) {
+        const group = config.columnGroups.find((g) => g.id === groupId);
+        if (!group) {
+          continue;
+        }
+        collected.push(...group.baseFields);
+        if (compareToLastWeek && group.lastWeekFields) {
+          collected.push(...group.lastWeekFields);
+        }
+        if (compareToLastYear && group.lastYearFields) {
+          collected.push(...group.lastYearFields);
+        }
+      }
+      return this.sortAndPrependPrefix(config, parameters, collected);
+    }
+    if (!selectedGroupIds && config.columnGroups?.length && (compareToLastWeek || compareToLastYear)) {
+      const collected = [];
+      for (const col of config.defaultVisibleColumns) {
+        collected.push(col);
+        const group = config.columnGroups.find((g) => g.baseFields.includes(col));
+        if (group) {
+          if (compareToLastWeek && group.lastWeekFields) {
+            collected.push(...group.lastWeekFields);
+          }
+          if (compareToLastYear && group.lastYearFields) {
+            collected.push(...group.lastYearFields);
+          }
+        }
+      }
+      return this.sortAndPrependPrefix(config, parameters, collected);
+    }
+    const metricCols = selectedGroupIds?.length ? config.availableColumns.filter((c) => selectedGroupIds.includes(c)) : config.defaultVisibleColumns;
+    return [...this.buildColumnPrefix(config, parameters), ...metricCols];
+  }
+  getColumnHeader(fieldName, config) {
+    const columnKey = config.fields[fieldName]?.columnKey;
+    const titleKey = columnKey ? getColumnMetadata(columnKey)?.shortTitleKey : void 0;
+    const colHeader = titleKey ? this.translate(titleKey) : fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (c) => c.toUpperCase()).trim();
+    const group = config.columnGroups?.find(
+      (g) => g.baseFields.includes(fieldName) || (g.lastWeekFields?.includes(fieldName) ?? false) || (g.lastYearFields?.includes(fieldName) ?? false)
+    );
+    return group ? getColumnExportHeaderLabel(colHeader, this.translate(group.headerTranslationKey)) : colHeader;
+  }
+  resolveColumnsAndHeaders(parameters, config) {
+    const columns = this.resolveColumns(config, parameters);
+    const headers = columns.map((col) => {
+      if (col === "groupByName2" && parameters.secondGroupBy) {
+        return this.translate(`analytics.field.${parameters.secondGroupBy}`);
+      }
+      return this.getColumnHeader(col, config);
+    });
+    const columnTypes = columns.map((col) => config.fields[col]);
+    return { columns, headers, columnTypes };
+  }
+  formatField(value, config, localeOption, fullRecord) {
+    if (!config || value === void 0 || value === null) {
+      return "";
+    }
+    const formatted = formatFieldValue(value, config.type, localeOption, fullRecord, config);
+    return typeof formatted === "string" && formatted in en_US_default ? this.translate(formatted) : formatted;
+  }
+  formatRow(raw, columns, columnTypes, localeConfig, fullRecord) {
+    const formatted = {};
+    columns.forEach((col, i) => {
+      formatted[col] = this.formatField(raw[col], columnTypes[i], localeConfig, fullRecord);
+    });
+    return formatted;
+  }
+  resolveLabelField(config, columns) {
+    if ("groupByName" in config.fields) {
+      return "groupByName";
+    }
+    const firstStringCol = columns.find((col) => {
+      const field = config.fields[col];
+      return field?.type === "string" && !field.footerCalculation;
+    });
+    return firstStringCol ?? columns[0] ?? "groupByName";
+  }
+  buildTotalsRow(data, config, columns) {
+    if (data.length === 0) {
+      return null;
+    }
+    const labelField = this.resolveLabelField(config, columns);
+    const label = config.totalsLabel ? this.translate(config.totalsLabel) : this.translate("table.total");
+    return calculateReportTotals(data, config.fields, { labelField, label });
+  }
+  getExtraFooterRows(data, config, sectionData, columns) {
+    if (config.extraFooterRowsKey) {
+      if (!Array.isArray(data)) {
+        const rows = data[config.extraFooterRowsKey];
+        if (Array.isArray(rows)) {
+          return rows;
+        }
+      }
+    }
+    if (config.extraFooterFields?.length && sectionData.length > 0) {
+      const labelField = this.resolveLabelField(config, columns);
+      const totals = calculateReportTotals(sectionData, config.fields, {
+        labelField,
+        label: this.translate("table.total")
+      });
+      const row = { [labelField]: totals[labelField] };
+      for (const field of config.extraFooterFields) {
+        row[field] = totals[field];
+      }
+      return [row];
+    }
+    return [];
+  }
+  renderTableContent(config, reportData, parameters) {
+    const localeConfig = this.getFormattingConfig();
+    const data = this.getDataForConfig(reportData, config);
+    const { columns, headers, columnTypes } = this.resolveColumnsAndHeaders(parameters, config);
+    const tableColumns = columns.map((col, i) => ({ header: headers[i], key: col }));
+    const rows = data.filter((row) => typeof row === "object" && row !== null).map((row) => this.formatRow(row, columns, columnTypes, localeConfig, row));
+    if (config.hasFooter) {
+      const totalsRow = this.buildTotalsRow(data, config, columns);
+      if (totalsRow) {
+        rows.push(this.formatRow(totalsRow, columns, columnTypes, localeConfig, null));
+      }
+    }
+    for (const extraRow of this.getExtraFooterRows(reportData, config, data, columns)) {
+      rows.push(this.formatRow(extraRow, columns, columnTypes, localeConfig, extraRow));
+    }
+    return { table: { columns: tableColumns, rows } };
+  }
+  getDataForConfig(data, config) {
+    if (Array.isArray(data)) {
+      return data;
+    }
+    return config.dataAccessKey ? data[config.dataAccessKey] ?? [] : [];
+  }
+  formatMaybeDate(value) {
+    const date = typeof value === "string" ? parseISO(value) : value;
+    if (!isValid(date)) {
+      return "";
+    }
+    return format(date, "yyyy-MM-dd");
+  }
+  buildMetadata(parameters) {
+    const rows = [];
+    rows.push([
+      this.translate("scheduled-reports.period"),
+      `${this.formatMaybeDate(parameters.startDate)} - ${this.formatMaybeDate(parameters.endDate)}`
+    ]);
+    if (parameters.groupBy) {
+      rows.push([
+        this.translate("components.form.field.group-by"),
+        this.translate(`analytics.field.${parameters.groupBy}`)
+      ]);
+    }
+    const locationNames = this.locations.map((l) => l.name);
+    if (locationNames.length > 0) {
+      rows.push([this.translate("common.labels.locations"), locationNames.join(", ")]);
+    }
+    if (parameters.compareToLastWeek === true) {
+      rows.push([this.translate("components.form.field.last-week"), this.translate("common.labels.yes")]);
+    }
+    if (parameters.compareToLastYear === true) {
+      rows.push([this.translate("components.form.field.last-year"), this.translate("common.labels.yes")]);
+    }
+    return rows;
+  }
+  getContent(reportData, parameters, name) {
+    const rawConfig = this.getConfig();
+    if (!rawConfig) {
+      throw new Error("Missing report config");
+    }
+    let sections;
+    if (Array.isArray(rawConfig)) {
+      sections = rawConfig.map((config) => ({
+        sheetName: this.getConfigSectionName(config),
+        ...this.renderTableContent(config, reportData, parameters)
+      }));
+    } else {
+      const metadata = this.buildMetadata(parameters);
+      sections = [
+        {
+          sheetName: name,
+          filters: metadata.map(([label, value]) => ({ label, value })),
+          ...this.renderTableContent(rawConfig, reportData, parameters)
+        }
+      ];
+    }
+    return sections;
+  }
+};
+export {
+  ExportBuilder
+};