@c8y/ngx-components 1021.13.3 → 1021.22.0

package/esm2022/datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/generators/csv-generator.mjs

@@ -0,0 +1,120 @@
+import { gettext } from '@c8y/ngx-components';
+class CSVDataTransformer {
+    transformToMergedFormat(exportData) {
+        const timeSeries = new Map();
+        const uniqueColumnIdentifiers = new Set();
+        exportData.forEach(({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {
+            const measurementIdentifier = this.createMeasurementIdentifier(device_name, fragment_series, unit, source);
+            if (!timeSeries.has(time)) {
+                timeSeries.set(time, {});
+            }
+            const timeEntry = timeSeries.get(time);
+            if (timeEntry) {
+                const minKey = this.formatMinKey(measurementIdentifier);
+                const maxKey = this.formatMaxKey(measurementIdentifier);
+                timeEntry[minKey] = value_min;
+                timeEntry[maxKey] = value_max;
+                uniqueColumnIdentifiers.add(minKey);
+                uniqueColumnIdentifiers.add(maxKey);
+            }
+        });
+        return {
+            timeSeries,
+            uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)
+        };
+    }
+    createMeasurementIdentifier(deviceName, fragmentSeries, unit, source) {
+        return unit
+            ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`
+            : `(${source}) ${deviceName} -> ${fragmentSeries}`;
+    }
+    formatMinKey(baseKey) {
+        return `${baseKey} (min)`;
+    }
+    formatMaxKey(baseKey) {
+        return `${baseKey} (max)`;
+    }
+}
+class CSVFileCreator {
+    async createFile(content, mimeType) {
+        return new Blob([content], { type: mimeType });
+    }
+}
+class CSVGenerator {
+    static getLabel() {
+        return gettext('Comma-separated value');
+    }
+    static getTitle() {
+        return 'CSV';
+    }
+    static getType() {
+        return 'csv';
+    }
+    static getIcon() {
+        return 'table';
+    }
+    static getFileExtension() {
+        return 'csv';
+    }
+    static getAcceptType() {
+        return 'text/csv';
+    }
+    static getMimeType() {
+        return 'text/csv';
+    }
+    static getZipName() {
+        return 'export_csv.zip';
+    }
+    static async convertToMergedCSV(exportData, mergedExportDetails) {
+        const instance = CSVGenerator.getInstance();
+        const { timeSeries, uniqueColumnIdentifiers } = instance.dataTransformer.transformToMergedFormat(exportData);
+        const rows = [
+            instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),
+            ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)
+        ];
+        const csvContent = rows.map(row => row.join(',')).join('\n');
+        return instance.fileCreator.createFile(csvContent, CSVGenerator.getMimeType());
+    }
+    static getInstance() {
+        if (!CSVGenerator.instance) {
+            CSVGenerator.instance = new CSVGenerator();
+        }
+        return CSVGenerator.instance;
+    }
+    constructor() {
+        this.dataTransformer = new CSVDataTransformer();
+        this.fileCreator = new CSVFileCreator();
+    }
+    createMergedFileHeaderRow(uniqueColumnIdentifiers, details) {
+        const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';
+        return [time, ...uniqueColumnIdentifiers];
+    }
+    createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers) {
+        return Array.from(timeSeries.entries())
+            .filter(([time, values]) => this.isValidEntry(time, values))
+            .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));
+    }
+    isValidEntry(time, values) {
+        return time !== null && Object.values(values).some(value => value != null);
+    }
+    createDataRow(time, values, uniqueColumnIdentifiers) {
+        const row = [time];
+        uniqueColumnIdentifiers.forEach(key => {
+            const value = values[key];
+            row.push(value?.toString() || '');
+        });
+        return row;
+    }
+}
+export const CSVGeneratorAdapter = {
+    getLabel: CSVGenerator.getLabel.bind(CSVGenerator),
+    getIcon: CSVGenerator.getIcon.bind(CSVGenerator),
+    getFileExtension: CSVGenerator.getFileExtension.bind(CSVGenerator),
+    getMimeType: CSVGenerator.getMimeType.bind(CSVGenerator),
+    generateMerged: CSVGenerator.convertToMergedCSV.bind(CSVGenerator),
+    getType: CSVGenerator.getType.bind(CSVGenerator),
+    getTitle: CSVGenerator.getTitle.bind(CSVGenerator),
+    getZipName: CSVGenerator.getZipName.bind(CSVGenerator),
+    getAcceptType: CSVGenerator.getAcceptType.bind(CSVGenerator)
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"csv-generator.js","sourceRoot":"","sources":["../../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/generators/csv-generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAa9C,MAAM,kBAAkB;IACtB,uBAAuB,CAAC,UAAwB;QAC9C,MAAM,UAAU,GAAG,IAAI,GAAG,EAAkC,CAAC;QAC7D,MAAM,uBAAuB,GAAG,IAAI,GAAG,EAAU,CAAC;QAElD,UAAU,CAAC,OAAO,CAChB,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE;YAC7E,MAAM,qBAAqB,GAAG,IAAI,CAAC,2BAA2B,CAC5D,WAAW,EACX,eAAe,EACf,IAAI,EACJ,MAAM,CACP,CAAC;YAEF,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC1B,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC3B,CAAC;YAED,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YACvC,IAAI,SAAS,EAAE,CAAC;gBACd,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;gBACxD,MAAM,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,qBAAqB,CAAC,CAAC;gBAExD,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;gBAC9B,SAAS,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;gBAE9B,uBAAuB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACpC,uBAAuB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YACtC,CAAC;QACH,CAAC,CACF,CAAC;QAEF,OAAO;YACL,UAAU;YACV,uBAAuB,EAAE,KAAK,CAAC,IAAI,CAAC,uBAAuB,CAAC;SAC7D,CAAC;IACJ,CAAC;IAEO,2BAA2B,CACjC,UAAkB,EAClB,cAAsB,EACtB,IAAY,EACZ,MAAuB;QAEvB,OAAO,IAAI;YACT,CAAC,CAAC,IAAI,MAAM,KAAK,UAAU,OAAO,cAAc,KAAK,IAAI,GAAG;YAC5D,CAAC,CAAC,IAAI,MAAM,KAAK,UAAU,OAAO,cAAc,EAAE,CAAC;IACvD,CAAC;IAEO,YAAY,CAAC,OAAe;QAClC,OAAO,GAAG,OAAO,QAAQ,CAAC;IAC5B,CAAC;IAEO,YAAY,CAAC,OAAe;QAClC,OAAO,GAAG,OAAO,QAAQ,CAAC;IAC5B,CAAC;CACF;AAED,MAAM,cAAc;IAClB,KAAK,CAAC,UAAU,CAAC,OAAe,EAAE,QAAgB;QAChD,OAAO,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IACjD,CAAC;CACF;AAED,MAAM,YAAY;IAChB,MAAM,CAAC,QAAQ;QACb,OAAO,OAAO,CAAC,uBAAuB,CAAC,CAAC;IAC1C,CAAC;IAED,MAAM,CAAC,QAAQ;QACb,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,gBAAgB;QACrB,OAAO,KAAK,CAAC;IACf,CAAC;IAED,MAAM,CAAC,aAAa;QAClB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,WAAW;QAChB,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,MAAM,CAAC,UAAU;QACf,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,KAAK,CAAC,kBAAkB,CAC7B,UAAwB,EACxB,mBAAwC;QAExC,MAAM,QAAQ,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;QAC5C,MAAM,EAAE,UAAU,EAAE,uBAAuB,EAAE,GAC3C,QAAQ,CAAC,eAAe,CAAC,uBAAuB,CAAC,UAAU,CAAC,CAAC;QAE/D,MAAM,IAAI,GAAG;YACX,QAAQ,CAAC,yBAAyB,CAAC,uBAAuB,EAAE,mBAAmB,CAAC;YAChF,GAAG,QAAQ,CAAC,wBAAwB,CAAC,UAAU,EAAE,uBAAuB,CAAC;SAC1E,CAAC;QAEF,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC7D,OAAO,QAAQ,CAAC,WAAW,CAAC,UAAU,CAAC,UAAU,EAAE,YAAY,CAAC,WAAW,EAAE,CAAC,CAAC;IACjF,CAAC;IAGO,MAAM,CAAC,WAAW;QACxB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;YAC3B,YAAY,CAAC,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;QAC7C,CAAC;QACD,OAAO,YAAY,CAAC,QAAQ,CAAC;IAC/B,CAAC;IAID;QACE,IAAI,CAAC,eAAe,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAChD,IAAI,CAAC,WAAW,GAAG,IAAI,cAAc,EAAE,CAAC;IAC1C,CAAC;IAEO,yBAAyB,CAC/B,uBAAiC,EACjC,OAA6B;QAE7B,MAAM,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,gBAAgB,OAAO,CAAC,QAAQ,OAAO,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC;QACxF,OAAO,CAAC,IAAI,EAAE,GAAG,uBAAuB,CAAC,CAAC;IAC5C,CAAC;IAEO,wBAAwB,CAC9B,UAA+C,EAC/C,uBAAiC;QAEjC,OAAO,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;aACpC,MAAM,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;aAC3D,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,uBAAuB,CAAC,CAAC,CAAC;IACxF,CAAC;IAEO,YAAY,CAAC,IAAY,EAAE,MAA8B;QAC/D,OAAO,IAAI,KAAK,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAC;IAC7E,CAAC;IAEO,aAAa,CACnB,IAAY,EACZ,MAA8B,EAC9B,uBAAiC;QAEjC,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC;QACnB,uBAAuB,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACpC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,GAAG,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAkB;IAChD,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;IAClD,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;IAChD,gBAAgB,EAAE,YAAY,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC;IAClE,WAAW,EAAE,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC;IACxD,cAAc,EAAE,YAAY,CAAC,kBAAkB,CAAC,IAAI,CAAC,YAAY,CAAC;IAClE,OAAO,EAAE,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC;IAChD,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC;IAClD,UAAU,EAAE,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC;IACtD,aAAa,EAAE,YAAY,CAAC,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC;CAC7D,CAAC","sourcesContent":["import { gettext } from '@c8y/ngx-components';\nimport {\n  ExportData,\n  FileGenerator,\n  IDataTransformer,\n  MergedExportDetails,\n  TimeSeriesColumnData\n} from '../../../datapoints-export-selector.model';\n\ninterface ICsvFileCreator {\n  createFile(content: string, mimeType: string): Promise<Blob>;\n}\n\nclass CSVDataTransformer implements IDataTransformer {\n  transformToMergedFormat(exportData: ExportData[]): TimeSeriesColumnData {\n    const timeSeries = new Map<string, Record<string, number>>();\n    const uniqueColumnIdentifiers = new Set<string>();\n\n    exportData.forEach(\n      ({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {\n        const measurementIdentifier = this.createMeasurementIdentifier(\n          device_name,\n          fragment_series,\n          unit,\n          source\n        );\n\n        if (!timeSeries.has(time)) {\n          timeSeries.set(time, {});\n        }\n\n        const timeEntry = timeSeries.get(time);\n        if (timeEntry) {\n          const minKey = this.formatMinKey(measurementIdentifier);\n          const maxKey = this.formatMaxKey(measurementIdentifier);\n\n          timeEntry[minKey] = value_min;\n          timeEntry[maxKey] = value_max;\n\n          uniqueColumnIdentifiers.add(minKey);\n          uniqueColumnIdentifiers.add(maxKey);\n        }\n      }\n    );\n\n    return {\n      timeSeries,\n      uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)\n    };\n  }\n\n  private createMeasurementIdentifier(\n    deviceName: string,\n    fragmentSeries: string,\n    unit: string,\n    source: string | number\n  ): string {\n    return unit\n      ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`\n      : `(${source}) ${deviceName} -> ${fragmentSeries}`;\n  }\n\n  private formatMinKey(baseKey: string): string {\n    return `${baseKey} (min)`;\n  }\n\n  private formatMaxKey(baseKey: string): string {\n    return `${baseKey} (max)`;\n  }\n}\n\nclass CSVFileCreator implements ICsvFileCreator {\n  async createFile(content: string, mimeType: string): Promise<Blob> {\n    return new Blob([content], { type: mimeType });\n  }\n}\n\nclass CSVGenerator {\n  static getLabel(): string {\n    return gettext('Comma-separated value');\n  }\n\n  static getTitle(): string {\n    return 'CSV';\n  }\n\n  static getType(): string {\n    return 'csv';\n  }\n\n  static getIcon(): string {\n    return 'table';\n  }\n\n  static getFileExtension(): string {\n    return 'csv';\n  }\n\n  static getAcceptType(): string {\n    return 'text/csv';\n  }\n\n  static getMimeType(): string {\n    return 'text/csv';\n  }\n\n  static getZipName(): string {\n    return 'export_csv.zip';\n  }\n\n  static async convertToMergedCSV(\n    exportData: ExportData[],\n    mergedExportDetails: MergedExportDetails\n  ): Promise<Blob> {\n    const instance = CSVGenerator.getInstance();\n    const { timeSeries, uniqueColumnIdentifiers } =\n      instance.dataTransformer.transformToMergedFormat(exportData);\n\n    const rows = [\n      instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),\n      ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)\n    ];\n\n    const csvContent = rows.map(row => row.join(',')).join('\\n');\n    return instance.fileCreator.createFile(csvContent, CSVGenerator.getMimeType());\n  }\n  private static instance: CSVGenerator;\n\n  private static getInstance(): CSVGenerator {\n    if (!CSVGenerator.instance) {\n      CSVGenerator.instance = new CSVGenerator();\n    }\n    return CSVGenerator.instance;\n  }\n  private dataTransformer: IDataTransformer;\n  private fileCreator: ICsvFileCreator;\n\n  private constructor() {\n    this.dataTransformer = new CSVDataTransformer();\n    this.fileCreator = new CSVFileCreator();\n  }\n\n  private createMergedFileHeaderRow(\n    uniqueColumnIdentifiers: string[],\n    details?: MergedExportDetails\n  ): string[] {\n    const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';\n    return [time, ...uniqueColumnIdentifiers];\n  }\n\n  private createMergedFileDataRows(\n    timeSeries: Map<string, Record<string, number>>,\n    uniqueColumnIdentifiers: string[]\n  ): string[][] {\n    return Array.from(timeSeries.entries())\n      .filter(([time, values]) => this.isValidEntry(time, values))\n      .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));\n  }\n\n  private isValidEntry(time: string, values: Record<string, number>): boolean {\n    return time !== null && Object.values(values).some(value => value != null);\n  }\n\n  private createDataRow(\n    time: string,\n    values: Record<string, number>,\n    uniqueColumnIdentifiers: string[]\n  ): string[] {\n    const row = [time];\n    uniqueColumnIdentifiers.forEach(key => {\n      const value = values[key];\n      row.push(value?.toString() || '');\n    });\n    return row;\n  }\n}\n\nexport const CSVGeneratorAdapter: FileGenerator = {\n  getLabel: CSVGenerator.getLabel.bind(CSVGenerator),\n  getIcon: CSVGenerator.getIcon.bind(CSVGenerator),\n  getFileExtension: CSVGenerator.getFileExtension.bind(CSVGenerator),\n  getMimeType: CSVGenerator.getMimeType.bind(CSVGenerator),\n  generateMerged: CSVGenerator.convertToMergedCSV.bind(CSVGenerator),\n  getType: CSVGenerator.getType.bind(CSVGenerator),\n  getTitle: CSVGenerator.getTitle.bind(CSVGenerator),\n  getZipName: CSVGenerator.getZipName.bind(CSVGenerator),\n  getAcceptType: CSVGenerator.getAcceptType.bind(CSVGenerator)\n};\n"]}

package/esm2022/datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/generators/excel-generator.mjs

@@ -0,0 +1,282 @@
+import { gettext } from '@c8y/ngx-components';
+import JSZip from 'jszip';
+import { isEmpty, isNil, isNumber } from 'lodash-es';
+import { FILE_COMPRESSION_TYPES_VALUES } from '../../../datapoints-export-selector.model';
+// Utility functions
+class XmlUtils {
+    static escapeXml(unsafe) {
+        return unsafe.replace(/[<>&'"]/g, c => {
+            switch (c) {
+                case '<':
+                    return '&lt;';
+                case '>':
+                    return '&gt;';
+                case '&':
+                    return '&amp;';
+                case "'":
+                    return '&apos;';
+                case '"':
+                    return '&quot;';
+            }
+        });
+    }
+}
+export class ExcelDataTransformer {
+    transformToMergedFormat(exportData) {
+        const timeSeries = new Map();
+        const uniqueColumnIdentifiers = new Set();
+        exportData.forEach(({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {
+            const measurementIdentifier = this.createMeasurementIdentifier(device_name, fragment_series, unit, source);
+            if (!timeSeries.has(time)) {
+                timeSeries.set(time, {});
+            }
+            const timeEntry = timeSeries.get(time);
+            if (timeEntry) {
+                const minKey = this.formatMinKey(measurementIdentifier);
+                const maxKey = this.formatMaxKey(measurementIdentifier);
+                timeEntry[minKey] = value_min;
+                timeEntry[maxKey] = value_max;
+                uniqueColumnIdentifiers.add(minKey);
+                uniqueColumnIdentifiers.add(maxKey);
+            }
+        });
+        return {
+            timeSeries,
+            uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)
+        };
+    }
+    createMeasurementIdentifier(deviceName, fragmentSeries, unit, source) {
+        return unit
+            ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`
+            : `(${source}) ${deviceName} -> ${fragmentSeries}`;
+    }
+    formatMinKey(baseKey) {
+        return `${baseKey} (min)`;
+    }
+    formatMaxKey(baseKey) {
+        return `${baseKey} (max)`;
+    }
+}
+class ExcelXmlGenerator {
+    constructor() {
+        this.columnWidths = {
+            time: 25,
+            source: 10,
+            device_name: 20,
+            'fragment.series': 20,
+            value_min: 15,
+            value_max: 15,
+            unit: 5
+        };
+        this.defaultWidth = 30;
+        this.RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n' +
+            '  <Relationship Id="rId1" Target="xl/workbook.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"/>\n' +
+            '  <Relationship Id="rId2" Target="docProps/app.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"/>\n' +
+            '  <Relationship Id="rId3" Target="docProps/core.xml" Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"/>\n' +
+            '</Relationships>';
+        this.CONTENT_TYPES_XML = '<?xml version="1.0" encoding="UTF-8" standalone="no"?>\n' +
+            '<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">\n' +
+            '  <Default ContentType="application/vnd.openxmlformats-package.relationships+xml" Extension="rels"/>\n' +
+            '  <Default ContentType="application/xml" Extension="xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml" PartName="/docProps/app.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-package.core-properties+xml" PartName="/docProps/core.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml" PartName="/xl/sharedStrings.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" PartName="/xl/workbook.xml"/>\n' +
+            '  <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet1.xml"/>\n' +
+            '</Types>';
+        this.WORKBOOK_RELS_XML = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">\n' +
+            '  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="sharedStrings.xml"/>\n' +
+            '  <Relationship Id="rId3" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>\n' +
+            '</Relationships>';
+        this.SHARED_STRINGS_XML = '<?xml version="1.0" encoding="UTF-8"?>\n' +
+            '<sst count="0" uniqueCount="0" xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"/>';
+    }
+    generateWorkbookXml(sheetName = 'Measurements') {
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            `<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name='${sheetName}' r:id="rId3" sheetId="1"/></sheets></workbook>`);
+    }
+    generateSheetXml(data) {
+        const headers = data[0];
+        const colsXml = this.generateColsXml(headers);
+        const rowsXml = this.generateRowsXml(data);
+        return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+      <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+        <cols>${colsXml}</cols>
+        <sheetData>${rowsXml}</sheetData>
+      </worksheet>`;
+    }
+    generateAppXml(name) {
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">\n' +
+            `  <Application>${name}</Application>\n` +
+            '  <DocSecurity>0</DocSecurity>\n' +
+            '  <ScaleCrop>false</ScaleCrop>\n' +
+            '  <HeadingPairs>\n' +
+            '    <vt:vector size="2" baseType="variant">\n' +
+            '      <vt:variant>\n' +
+            '        <vt:lpstr>Worksheets</vt:lpstr>\n' +
+            '      </vt:variant>\n' +
+            '      <vt:variant>\n' +
+            '        <vt:i4>1</vt:i4>\n' +
+            '      </vt:variant>\n' +
+            '    </vt:vector>\n' +
+            '  </HeadingPairs>\n' +
+            '  <TitlesOfParts>\n' +
+            '    <vt:vector size="1" baseType="lpstr">\n' +
+            '      <vt:lpstr>Sheet1</vt:lpstr>\n' +
+            '    </vt:vector>\n' +
+            '  </TitlesOfParts>\n' +
+            '  <Company></Company>\n' +
+            '  <LinksUpToDate>false</LinksUpToDate>\n' +
+            '  <SharedDoc>false</SharedDoc>\n' +
+            '  <HyperlinksChanged>false</HyperlinksChanged>\n' +
+            '  <AppVersion>16.0300</AppVersion>\n' +
+            '</Properties>');
+    }
+    generateCoreXml(name) {
+        const now = new Date().toISOString();
+        return ('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n' +
+            '<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">\n' +
+            `  <dc:creator>${name}</dc:creator>\n` +
+            `  <cp:lastModifiedBy>${name}</cp:lastModifiedBy>\n` +
+            `  <dcterms:created xsi:type="dcterms:W3CDTF">${now}</dcterms:created>\n` +
+            `  <dcterms:modified xsi:type="dcterms:W3CDTF">${now}</dcterms:modified>\n` +
+            '</cp:coreProperties>');
+    }
+    generateColsXml(headers) {
+        return headers
+            .map((header, index) => {
+            const width = this.columnWidths[header] || this.defaultWidth;
+            return `<col min="${index + 1}" max="${index + 1}" width="${width}" customWidth="1"/>`;
+        })
+            .join('');
+    }
+    generateRowsXml(data) {
+        return data
+            .map(row => `<row>${row
+            .map(cell => {
+            if (isNil(cell) || isEmpty(cell)) {
+                return `<c t="inlineStr"><is><t></t></is></c>`; // String cell
+            }
+            else if (isNumber(Number(cell)) && !isNaN(Number(cell))) {
+                return `<c t="n"><v>${Number(cell)}</v></c>`; // Number cell
+            }
+            else {
+                return `<c t="inlineStr"><is><t>${XmlUtils.escapeXml(cell)}</t></is></c>`; // String cell
+            }
+        })
+            .join('')}</row>`)
+            .join('');
+    }
+}
+class ZipFileCreator {
+    async createZipFile(contents, compressionType, compressionLevel) {
+        const zip = new JSZip();
+        const blob = 'blob';
+        contents.forEach((content, filename) => {
+            zip.file(filename, content);
+        });
+        const options = { type: blob };
+        if (compressionType !== FILE_COMPRESSION_TYPES_VALUES.store) {
+            options.compression = compressionType;
+            options.compressionOptions = { level: compressionLevel };
+        }
+        return (await zip.generateAsync(options));
+    }
+}
+class ExcelGenerator {
+    static getLabel() {
+        return gettext('Microsoft Excel');
+    }
+    static getTitle() {
+        return 'Excel';
+    }
+    static getType() {
+        return 'excel';
+    }
+    static getIcon() {
+        return 'excel';
+    }
+    static getFileExtension() {
+        return 'xlsx';
+    }
+    static getAcceptType() {
+        return 'application/vnd.ms-excel';
+    }
+    static getMimeType() {
+        return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+    }
+    static getZipName() {
+        return 'export_excel.zip';
+    }
+    static async convertToMergedExcel(exportData, mergedExportDetails) {
+        const instance = ExcelGenerator.getInstance();
+        const { timeSeries, uniqueColumnIdentifiers } = instance.dataTransformer.transformToMergedFormat(exportData);
+        const rows = [
+            instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),
+            ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)
+        ];
+        return instance.createExcelFile(rows, mergedExportDetails);
+    }
+    static getInstance() {
+        if (!ExcelGenerator.instance) {
+            ExcelGenerator.instance = new ExcelGenerator();
+        }
+        return ExcelGenerator.instance;
+    }
+    constructor() {
+        this.dataTransformer = new ExcelDataTransformer();
+        this.xmlGenerator = new ExcelXmlGenerator();
+        this.fileCreator = new ZipFileCreator();
+    }
+    async createExcelFile(data, details) {
+        const contents = new Map([
+            ['[Content_Types].xml', this.xmlGenerator.CONTENT_TYPES_XML],
+            ['_rels/.rels', this.xmlGenerator.RELS_XML],
+            [
+                'xl/workbook.xml',
+                this.xmlGenerator.generateWorkbookXml(details?.aggregation ? details?.aggregation : 'NO AGGREGATION')
+            ],
+            ['xl/worksheets/sheet1.xml', this.xmlGenerator.generateSheetXml(data)],
+            ['xl/sharedStrings.xml', this.xmlGenerator.SHARED_STRINGS_XML],
+            ['docProps/app.xml', this.xmlGenerator.generateAppXml('Custom Script')],
+            ['docProps/core.xml', this.xmlGenerator.generateCoreXml('Custom Script')],
+            ['xl/_rels/workbook.xml.rels', this.xmlGenerator.WORKBOOK_RELS_XML]
+        ]);
+        return this.fileCreator.createZipFile(contents, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);
+    }
+    createMergedFileHeaderRow(uniqueColumnIdentifiers, details) {
+        const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';
+        return [time, ...uniqueColumnIdentifiers];
+    }
+    createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers) {
+        return Array.from(timeSeries.entries())
+            .filter(([time, values]) => this.isValidEntry(time, values))
+            .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));
+    }
+    isValidEntry(time, values) {
+        return (time !== null && Object.values(values).some(value => value !== null && value !== undefined));
+    }
+    createDataRow(time, values, uniqueColumnIdentifiers) {
+        const row = [time];
+        uniqueColumnIdentifiers.forEach(key => {
+            const value = values[key];
+            row.push(value !== undefined && value !== null ? value.toString() : '');
+        });
+        return row;
+    }
+}
+export const ExcelGeneratorAdapter = {
+    getLabel: ExcelGenerator.getLabel.bind(ExcelGenerator),
+    getIcon: ExcelGenerator.getIcon.bind(ExcelGenerator),
+    getFileExtension: ExcelGenerator.getFileExtension.bind(ExcelGenerator),
+    getMimeType: ExcelGenerator.getMimeType.bind(ExcelGenerator),
+    generateMerged: ExcelGenerator.convertToMergedExcel.bind(ExcelGenerator),
+    getType: ExcelGenerator.getType.bind(ExcelGenerator),
+    getTitle: ExcelGenerator.getTitle.bind(ExcelGenerator),
+    getZipName: ExcelGenerator.getZipName.bind(ExcelGenerator),
+    getAcceptType: ExcelGenerator.getAcceptType.bind(ExcelGenerator)
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"excel-generator.js","sourceRoot":"","sources":["../../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/generators/excel-generator.ts"],"names":[],"mappings":"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","sourcesContent":["import { gettext } from '@c8y/ngx-components';\nimport JSZip from 'jszip';\nimport { isEmpty, isNil, isNumber } from 'lodash-es';\nimport {\n  ExportData,\n  FILE_COMPRESSION_TYPES_VALUES,\n  FileCompressionTypes,\n  FileGenerator,\n  IDataTransformer,\n  MergedExportDetails,\n  TimeSeriesColumnData\n} from '../../../datapoints-export-selector.model';\n\ninterface IXmlGenerator {\n  RELS_XML: string;\n  CONTENT_TYPES_XML: string;\n  WORKBOOK_RELS_XML: string;\n  SHARED_STRINGS_XML: string;\n  generateWorkbookXml(sheetName?: string): string;\n  generateSheetXml(data: string[][]): string;\n  generateAppXml(name: string): string;\n  generateCoreXml(name: string): string;\n}\n\ninterface IXmlFileCreator {\n  createZipFile(\n    contents: Map<string, string>,\n    compressionType: FileCompressionTypes,\n    compressionLevel: number\n  ): Promise<Blob>;\n}\n\n// Utility functions\nclass XmlUtils {\n  static escapeXml(unsafe: string): string {\n    return unsafe.replace(/[<>&'\"]/g, c => {\n      switch (c) {\n        case '<':\n          return '&lt;';\n        case '>':\n          return '&gt;';\n        case '&':\n          return '&amp;';\n        case \"'\":\n          return '&apos;';\n        case '\"':\n          return '&quot;';\n      }\n    });\n  }\n}\n\nexport class ExcelDataTransformer implements IDataTransformer {\n  transformToMergedFormat(exportData: ExportData[]): TimeSeriesColumnData {\n    const timeSeries = new Map<string, Record<string, number>>();\n    const uniqueColumnIdentifiers = new Set<string>();\n\n    exportData.forEach(\n      ({ time, device_name, fragment_series, unit, value_min, value_max, source }) => {\n        const measurementIdentifier = this.createMeasurementIdentifier(\n          device_name,\n          fragment_series,\n          unit,\n          source\n        );\n\n        if (!timeSeries.has(time)) {\n          timeSeries.set(time, {});\n        }\n\n        const timeEntry = timeSeries.get(time);\n        if (timeEntry) {\n          const minKey = this.formatMinKey(measurementIdentifier);\n          const maxKey = this.formatMaxKey(measurementIdentifier);\n\n          timeEntry[minKey] = value_min;\n          timeEntry[maxKey] = value_max;\n\n          uniqueColumnIdentifiers.add(minKey);\n          uniqueColumnIdentifiers.add(maxKey);\n        }\n      }\n    );\n\n    return {\n      timeSeries,\n      uniqueColumnIdentifiers: Array.from(uniqueColumnIdentifiers)\n    };\n  }\n\n  private createMeasurementIdentifier(\n    deviceName: string,\n    fragmentSeries: string,\n    unit: string,\n    source: string | number\n  ): string {\n    return unit\n      ? `(${source}) ${deviceName} -> ${fragmentSeries} [${unit}]`\n      : `(${source}) ${deviceName} -> ${fragmentSeries}`;\n  }\n\n  private formatMinKey(baseKey: string): string {\n    return `${baseKey} (min)`;\n  }\n\n  private formatMaxKey(baseKey: string): string {\n    return `${baseKey} (max)`;\n  }\n}\n\nclass ExcelXmlGenerator implements IXmlGenerator {\n  private columnWidths = {\n    time: 25,\n    source: 10,\n    device_name: 20,\n    'fragment.series': 20,\n    value_min: 15,\n    value_max: 15,\n    unit: 5\n  };\n  private defaultWidth = 30;\n\n  readonly RELS_XML =\n    '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n' +\n    '<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\\n' +\n    '  <Relationship Id=\"rId1\" Target=\"xl/workbook.xml\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\"/>\\n' +\n    '  <Relationship Id=\"rId2\" Target=\"docProps/app.xml\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties\"/>\\n' +\n    '  <Relationship Id=\"rId3\" Target=\"docProps/core.xml\" Type=\"http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties\"/>\\n' +\n    '</Relationships>';\n\n  readonly CONTENT_TYPES_XML =\n    '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\\n' +\n    '<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">\\n' +\n    '  <Default ContentType=\"application/vnd.openxmlformats-package.relationships+xml\" Extension=\"rels\"/>\\n' +\n    '  <Default ContentType=\"application/xml\" Extension=\"xml\"/>\\n' +\n    '  <Override ContentType=\"application/vnd.openxmlformats-officedocument.extended-properties+xml\" PartName=\"/docProps/app.xml\"/>\\n' +\n    '  <Override ContentType=\"application/vnd.openxmlformats-package.core-properties+xml\" PartName=\"/docProps/core.xml\"/>\\n' +\n    '  <Override ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml\" PartName=\"/xl/sharedStrings.xml\"/>\\n' +\n    '  <Override ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml\" PartName=\"/xl/workbook.xml\"/>\\n' +\n    '  <Override ContentType=\"application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml\" PartName=\"/xl/worksheets/sheet1.xml\"/>\\n' +\n    '</Types>';\n\n  readonly WORKBOOK_RELS_XML =\n    '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n' +\n    '<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">\\n' +\n    '  <Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings\" Target=\"sharedStrings.xml\"/>\\n' +\n    '  <Relationship Id=\"rId3\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet\" Target=\"worksheets/sheet1.xml\"/>\\n' +\n    '</Relationships>';\n\n  readonly SHARED_STRINGS_XML =\n    '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n' +\n    '<sst count=\"0\" uniqueCount=\"0\" xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\"/>';\n\n  generateWorkbookXml(sheetName = 'Measurements'): string {\n    return (\n      '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n' +\n      `<workbook xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\"><sheets><sheet name='${sheetName}' r:id=\"rId3\" sheetId=\"1\"/></sheets></workbook>`\n    );\n  }\n\n  generateSheetXml(data: string[][]): string {\n    const headers = data[0];\n    const colsXml = this.generateColsXml(headers);\n    const rowsXml = this.generateRowsXml(data);\n\n    return `<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n      <worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\" xmlns:r=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships\">\n        <cols>${colsXml}</cols>\n        <sheetData>${rowsXml}</sheetData>\n      </worksheet>`;\n  }\n\n  generateAppXml(name: string): string {\n    return (\n      '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n' +\n      '<Properties xmlns=\"http://schemas.openxmlformats.org/officeDocument/2006/extended-properties\" xmlns:vt=\"http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes\">\\n' +\n      `  <Application>${name}</Application>\\n` +\n      '  <DocSecurity>0</DocSecurity>\\n' +\n      '  <ScaleCrop>false</ScaleCrop>\\n' +\n      '  <HeadingPairs>\\n' +\n      '    <vt:vector size=\"2\" baseType=\"variant\">\\n' +\n      '      <vt:variant>\\n' +\n      '        <vt:lpstr>Worksheets</vt:lpstr>\\n' +\n      '      </vt:variant>\\n' +\n      '      <vt:variant>\\n' +\n      '        <vt:i4>1</vt:i4>\\n' +\n      '      </vt:variant>\\n' +\n      '    </vt:vector>\\n' +\n      '  </HeadingPairs>\\n' +\n      '  <TitlesOfParts>\\n' +\n      '    <vt:vector size=\"1\" baseType=\"lpstr\">\\n' +\n      '      <vt:lpstr>Sheet1</vt:lpstr>\\n' +\n      '    </vt:vector>\\n' +\n      '  </TitlesOfParts>\\n' +\n      '  <Company></Company>\\n' +\n      '  <LinksUpToDate>false</LinksUpToDate>\\n' +\n      '  <SharedDoc>false</SharedDoc>\\n' +\n      '  <HyperlinksChanged>false</HyperlinksChanged>\\n' +\n      '  <AppVersion>16.0300</AppVersion>\\n' +\n      '</Properties>'\n    );\n  }\n\n  generateCoreXml(name: string): string {\n    const now = new Date().toISOString();\n    return (\n      '<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\\n' +\n      '<cp:coreProperties xmlns:cp=\"http://schemas.openxmlformats.org/package/2006/metadata/core-properties\" xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:dcterms=\"http://purl.org/dc/terms/\" xmlns:dcmitype=\"http://purl.org/dc/dcmitype/\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\\n' +\n      `  <dc:creator>${name}</dc:creator>\\n` +\n      `  <cp:lastModifiedBy>${name}</cp:lastModifiedBy>\\n` +\n      `  <dcterms:created xsi:type=\"dcterms:W3CDTF\">${now}</dcterms:created>\\n` +\n      `  <dcterms:modified xsi:type=\"dcterms:W3CDTF\">${now}</dcterms:modified>\\n` +\n      '</cp:coreProperties>'\n    );\n  }\n\n  private generateColsXml(headers: string[]): string {\n    return headers\n      .map((header, index) => {\n        const width = this.columnWidths[header] || this.defaultWidth;\n        return `<col min=\"${index + 1}\" max=\"${index + 1}\" width=\"${width}\" customWidth=\"1\"/>`;\n      })\n      .join('');\n  }\n\n  private generateRowsXml(data: string[][]): string {\n    return data\n      .map(\n        row =>\n          `<row>${row\n            .map(cell => {\n              if (isNil(cell) || isEmpty(cell)) {\n                return `<c t=\"inlineStr\"><is><t></t></is></c>`; // String cell\n              } else if (isNumber(Number(cell)) && !isNaN(Number(cell))) {\n                return `<c t=\"n\"><v>${Number(cell)}</v></c>`; // Number cell\n              } else {\n                return `<c t=\"inlineStr\"><is><t>${XmlUtils.escapeXml(cell)}</t></is></c>`; // String cell\n              }\n            })\n            .join('')}</row>`\n      )\n      .join('');\n  }\n}\n\nclass ZipFileCreator implements IXmlFileCreator {\n  async createZipFile(\n    contents: Map<string, string>,\n    compressionType: FileCompressionTypes,\n    compressionLevel: number\n  ): Promise<Blob> {\n    const zip = new JSZip();\n    const blob = 'blob';\n\n    contents.forEach((content, filename) => {\n      zip.file(filename, content);\n    });\n\n    const options: JSZip.JSZipGeneratorOptions = { type: blob };\n    if (compressionType !== FILE_COMPRESSION_TYPES_VALUES.store) {\n      options.compression = compressionType;\n      options.compressionOptions = { level: compressionLevel };\n    }\n\n    return (await zip.generateAsync(options)) as Blob;\n  }\n}\n\nclass ExcelGenerator {\n  static getLabel(): string {\n    return gettext('Microsoft Excel');\n  }\n\n  static getTitle(): string {\n    return 'Excel';\n  }\n\n  static getType(): string {\n    return 'excel';\n  }\n\n  static getIcon(): string {\n    return 'excel';\n  }\n\n  static getFileExtension(): string {\n    return 'xlsx';\n  }\n\n  static getAcceptType(): string {\n    return 'application/vnd.ms-excel';\n  }\n\n  static getMimeType(): string {\n    return 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';\n  }\n\n  static getZipName(): string {\n    return 'export_excel.zip';\n  }\n\n  static async convertToMergedExcel(\n    exportData: ExportData[],\n    mergedExportDetails: MergedExportDetails\n  ): Promise<Blob> {\n    const instance = ExcelGenerator.getInstance();\n    const { timeSeries, uniqueColumnIdentifiers } =\n      instance.dataTransformer.transformToMergedFormat(exportData);\n\n    const rows = [\n      instance.createMergedFileHeaderRow(uniqueColumnIdentifiers, mergedExportDetails),\n      ...instance.createMergedFileDataRows(timeSeries, uniqueColumnIdentifiers)\n    ];\n\n    return instance.createExcelFile(rows, mergedExportDetails);\n  }\n\n  private static getInstance(): ExcelGenerator {\n    if (!ExcelGenerator.instance) {\n      ExcelGenerator.instance = new ExcelGenerator();\n    }\n    return ExcelGenerator.instance;\n  }\n\n  private static instance: ExcelGenerator;\n  private dataTransformer: IDataTransformer;\n  private xmlGenerator: IXmlGenerator;\n  private fileCreator: IXmlFileCreator;\n\n  private constructor() {\n    this.dataTransformer = new ExcelDataTransformer();\n    this.xmlGenerator = new ExcelXmlGenerator();\n    this.fileCreator = new ZipFileCreator();\n  }\n\n  private async createExcelFile(data: string[][], details?: MergedExportDetails): Promise<Blob> {\n    const contents = new Map<string, string>([\n      ['[Content_Types].xml', this.xmlGenerator.CONTENT_TYPES_XML],\n      ['_rels/.rels', this.xmlGenerator.RELS_XML],\n      [\n        'xl/workbook.xml',\n        this.xmlGenerator.generateWorkbookXml(\n          details?.aggregation ? details?.aggregation : 'NO AGGREGATION'\n        )\n      ],\n      ['xl/worksheets/sheet1.xml', this.xmlGenerator.generateSheetXml(data)],\n      ['xl/sharedStrings.xml', this.xmlGenerator.SHARED_STRINGS_XML],\n      ['docProps/app.xml', this.xmlGenerator.generateAppXml('Custom Script')],\n      ['docProps/core.xml', this.xmlGenerator.generateCoreXml('Custom Script')],\n      ['xl/_rels/workbook.xml.rels', this.xmlGenerator.WORKBOOK_RELS_XML]\n    ]);\n\n    return this.fileCreator.createZipFile(contents, FILE_COMPRESSION_TYPES_VALUES.deflate, 9);\n  }\n\n  private createMergedFileHeaderRow(\n    uniqueColumnIdentifiers: string[],\n    details?: MergedExportDetails\n  ): string[] {\n    const time = details ? `time => from ${details.dateFrom} to ${details.dateTo}` : 'time';\n    return [time, ...uniqueColumnIdentifiers];\n  }\n\n  private createMergedFileDataRows(\n    timeSeries: Map<string, Record<string, number>>,\n    uniqueColumnIdentifiers: string[]\n  ): string[][] {\n    return Array.from(timeSeries.entries())\n      .filter(([time, values]) => this.isValidEntry(time, values))\n      .map(([time, values]) => this.createDataRow(time, values, uniqueColumnIdentifiers));\n  }\n\n  private isValidEntry(time: string, values: Record<string, number>): boolean {\n    return (\n      time !== null && Object.values(values).some(value => value !== null && value !== undefined)\n    );\n  }\n\n  private createDataRow(\n    time: string,\n    values: Record<string, number>,\n    uniqueColumnIdentifiers: string[]\n  ): string[] {\n    const row = [time];\n    uniqueColumnIdentifiers.forEach(key => {\n      const value = values[key];\n      row.push(value !== undefined && value !== null ? value.toString() : '');\n    });\n    return row;\n  }\n}\n\nexport const ExcelGeneratorAdapter: FileGenerator = {\n  getLabel: ExcelGenerator.getLabel.bind(ExcelGenerator),\n  getIcon: ExcelGenerator.getIcon.bind(ExcelGenerator),\n  getFileExtension: ExcelGenerator.getFileExtension.bind(ExcelGenerator),\n  getMimeType: ExcelGenerator.getMimeType.bind(ExcelGenerator),\n  generateMerged: ExcelGenerator.convertToMergedExcel.bind(ExcelGenerator),\n  getType: ExcelGenerator.getType.bind(ExcelGenerator),\n  getTitle: ExcelGenerator.getTitle.bind(ExcelGenerator),\n  getZipName: ExcelGenerator.getZipName.bind(ExcelGenerator),\n  getAcceptType: ExcelGenerator.getAcceptType.bind(ExcelGenerator)\n};\n"]}

package/esm2022/datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/utils.service.mjs

@@ -0,0 +1,76 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class UtilsService {
+    transformDataStructure(data) {
+        const result = {};
+        data.forEach(sourceItem => {
+            const { source: sourceId, data: sourceData } = sourceItem;
+            result[sourceId] = {};
+            sourceData.series.forEach((seriesInfo, index) => {
+                const { type, name, unit } = seriesInfo;
+                /**
+                 * Unique key to distinguish between different series from same source,
+                 * e.g.: c8y_Acceleration.accelerationX, c8y_Acceleration.accelerationY, c8y_Acceleration.accelerationZ
+                 */
+                const seriesKey = `${type}.${name}`;
+                result[sourceId][seriesKey] = {
+                    values: {},
+                    seriesDetails: { name, unit, type }
+                };
+                let hasValues = false;
+                Object.entries(sourceData.values).forEach(([timestamp, measurements]) => {
+                    if (!measurements) {
+                        return;
+                    }
+                    const measurement = measurements[index];
+                    if (measurement !== null && measurement !== undefined) {
+                        result[sourceId][seriesKey].values[timestamp] = measurement;
+                        hasValues = true;
+                    }
+                });
+                if (!hasValues) {
+                    result[sourceId][seriesKey].values = null;
+                }
+            });
+        });
+        return result;
+    }
+    /**
+     * Formats a date range into a specific string format, handling UTC dates correctly.
+     *
+     * @param fromDate - The start date in ISO format (e.g., "2023-12-04T12:40:00.000Z")
+     * @param toDate - The end date in ISO format (e.g., "2023-12-06T23:50:00.000Z")
+     * @returns A string representing the date range in the format "ddmmmyyhhmm-ddmmmyyhhmm"
+     *          where d=day, m=month, y=year, h=hour, m=minute
+     *
+     * Example
+     * ```typescript
+     * const fromDate = "2023-12-04T12:40:00.000Z";
+     * const toDate = "2023-12-06T23:50:00.000Z";
+     * const formattedRange = getFormattedDateRange(fromDate, toDate);
+     * console.log(formattedRange); // Output: "04dec231240-06dec232350"
+     * ```
+     */
+    getFormattedDateRange(fromDate, toDate) {
+        const formatDate = (dateString) => {
+            const date = new Date(dateString);
+            if (isNaN(date.getTime())) {
+                throw new Error(`Invalid date string: ${dateString}`);
+            }
+            const day = date.getUTCDate().toString().padStart(2, '0');
+            const month = date.toLocaleString('en', { month: 'short', timeZone: 'UTC' }).toLowerCase();
+            const hours = date.getUTCHours().toString().padStart(2, '0');
+            const minutes = date.getUTCMinutes().toString().padStart(2, '0');
+            const seconds = date.getUTCSeconds().toString().padStart(2, '0');
+            return `${day}${month}${hours}${minutes}${seconds}`;
+        };
+        return `${formatDate(fromDate)}-${formatDate(toDate)}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: UtilsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.service.js","sourceRoot":"","sources":["../../../../../datapoints-export-selector/datapoints-export-selector-modal/datapoints-export-selector-file-exporter/utils.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nexport type Measurement = number | { min: number; max: number };\n\nexport interface SeriesInfo {\n  unit: string | null | undefined;\n  name: string;\n  type: string | null | undefined;\n}\n\nexport interface SourceData {\n  series: SeriesInfo[];\n  values: {\n    [timestamp: string]: (Measurement | null)[] | undefined;\n  };\n  truncated: boolean;\n}\n\nexport interface SourceItem {\n  source: string | number;\n  data: SourceData;\n}\n\nexport interface TransformedSeries {\n  values: { [timestamp: string]: Measurement } | null;\n  seriesDetails: SeriesInfo;\n}\n\nexport interface TransformedSource {\n  [seriesType: string]: TransformedSeries;\n}\n\nexport interface TransformedData {\n  [sourceId: string]: TransformedSource;\n}\n\n@Injectable({ providedIn: 'root' })\nexport class UtilsService {\n  transformDataStructure(data: SourceItem[]): TransformedData {\n    const result: TransformedData = {};\n\n    data.forEach(sourceItem => {\n      const { source: sourceId, data: sourceData } = sourceItem;\n      result[sourceId] = {};\n\n      sourceData.series.forEach((seriesInfo, index) => {\n        const { type, name, unit } = seriesInfo;\n        /**\n         * Unique key to distinguish between different series from same source,\n         * e.g.: c8y_Acceleration.accelerationX, c8y_Acceleration.accelerationY, c8y_Acceleration.accelerationZ\n         */\n        const seriesKey = `${type}.${name}`;\n\n        result[sourceId][seriesKey] = {\n          values: {},\n          seriesDetails: { name, unit, type }\n        };\n\n        let hasValues = false;\n        Object.entries(sourceData.values).forEach(([timestamp, measurements]) => {\n          if (!measurements) {\n            return;\n          }\n          const measurement = measurements[index];\n\n          if (measurement !== null && measurement !== undefined) {\n            result[sourceId][seriesKey].values[timestamp] = measurement;\n            hasValues = true;\n          }\n        });\n\n        if (!hasValues) {\n          result[sourceId][seriesKey].values = null;\n        }\n      });\n    });\n\n    return result;\n  }\n\n  /**\n   * Formats a date range into a specific string format, handling UTC dates correctly.\n   *\n   * @param fromDate - The start date in ISO format (e.g., \"2023-12-04T12:40:00.000Z\")\n   * @param toDate - The end date in ISO format (e.g., \"2023-12-06T23:50:00.000Z\")\n   * @returns A string representing the date range in the format \"ddmmmyyhhmm-ddmmmyyhhmm\"\n   *          where d=day, m=month, y=year, h=hour, m=minute\n   *\n   * Example\n   * ```typescript\n   * const fromDate = \"2023-12-04T12:40:00.000Z\";\n   * const toDate = \"2023-12-06T23:50:00.000Z\";\n   * const formattedRange = getFormattedDateRange(fromDate, toDate);\n   * console.log(formattedRange); // Output: \"04dec231240-06dec232350\"\n   * ```\n   */\n  getFormattedDateRange(fromDate: string, toDate: string): string {\n    const formatDate = (dateString: string): string => {\n      const date = new Date(dateString);\n      if (isNaN(date.getTime())) {\n        throw new Error(`Invalid date string: ${dateString}`);\n      }\n      const day = date.getUTCDate().toString().padStart(2, '0');\n      const month = date.toLocaleString('en', { month: 'short', timeZone: 'UTC' }).toLowerCase();\n      const hours = date.getUTCHours().toString().padStart(2, '0');\n      const minutes = date.getUTCMinutes().toString().padStart(2, '0');\n      const seconds = date.getUTCSeconds().toString().padStart(2, '0');\n      return `${day}${month}${hours}${minutes}${seconds}`;\n    };\n\n    return `${formatDate(fromDate)}-${formatDate(toDate)}`;\n  }\n}\n"]}