Merge branch 'bug-extended-chart' into main

Author: singerla

__tests__/pptx-templates/ChartWaterfall.pptx

@@ -1,7 +1,7 @@
 import JSZip from 'jszip';
 
 import { XmlHelper } from '../helper/xml-helper';
-import { GeneralHelper } from '../helper/general-helper';
+import { GeneralHelper, vd } from '../helper/general-helper';
 import {
   ImportedElement,
   ShapeModificationCallback,
@@ -10,6 +10,7 @@ import {
 import { RootPresTemplate } from '../interfaces/root-pres-template';
 import { HelperElement } from '../types/xml-types';
 import { ImageTypeMap } from '../enums/image-type-map';
+import { ElementSubtype } from '../enums/element-type';
 
 export class Shape {
   mode: string;
@@ -42,6 +43,7 @@ export class Shape {
   callbacks: ShapeModificationCallback[];
   hasCreationId: boolean;
   contentTypeMap: typeof ImageTypeMap;
+  subtype: ElementSubtype;
 
   constructor(shape: ImportedElement) {
     this.mode = shape.mode;
@@ -55,9 +57,11 @@ export class Shape {
 
     this.callbacks = GeneralHelper.arrayify(shape.callback);
     this.contentTypeMap = ImageTypeMap;
+
     if (shape.target) {
       this.sourceNumber = shape.target.number;
       this.sourceRid = shape.target.rId;
+      this.subtype = shape.target.subtype;
     }
   }
 

src/classes/shape.ts

@@ -421,14 +421,31 @@ export class Slide implements ISlide {
   ): Promise<AnalyzedElementType> {
     const isChart = sourceElement.getElementsByTagName('c:chart');
     if (isChart.length) {
+      const target = await XmlHelper.getTargetByRelId(
+        sourceArchive,
+        slideNumber,
+        sourceElement,
+        'chart',
+      );
+
       return {
         type: ElementType.Chart,
-        target: await XmlHelper.getTargetByRelId(
-          sourceArchive,
-          slideNumber,
-          sourceElement,
-          'chart',
-        ),
+        target: target,
+      } as AnalyzedElementType;
+    }
+
+    const isChartEx = sourceElement.getElementsByTagName('cx:chart');
+    if (isChartEx.length) {
+      const target = await XmlHelper.getTargetByRelId(
+        sourceArchive,
+        slideNumber,
+        sourceElement,
+        'chartEx',
+      );
+
+      return {
+        type: ElementType.Chart,
+        target: target,
       } as AnalyzedElementType;
     }
 
@@ -681,6 +698,7 @@ export class Slide implements ISlide {
    */
   async copyRelatedContent(): Promise<void> {
     const charts = await Chart.getAllOnSlide(this.sourceArchive, this.relsPath);
+
     for (const chart of charts) {
       await new Chart({
         mode: 'append',

src/classes/slide.ts

@@ -6,6 +6,11 @@ export const TargetByRelIdMap = {
     relAttribute: 'r:id',
     prefix: '../charts/chart',
   } as TargetByRelIdMapParam,
+  chartEx: {
+    relRootTag: 'cx:chart',
+    relAttribute: 'r:id',
+    prefix: '../charts/chartEx',
+  } as TargetByRelIdMapParam,
   image: {
     relRootTag: 'a:blip',
     relAttribute: 'r:embed',

src/constants/constants.ts

@@ -17,17 +17,41 @@ const automizer = new Automizer({
 const run = async () => {
   const ppt = automizer
     .loadRoot(`RootTemplate.pptx`)
-    .load(`SlideWithCharts.pptx`, 'charts')
-    .load(`SlideWithImages.pptx`, 'images');
+    .load(`EmptySlide.pptx`, 'EmptySlide')
+    .load(`ChartWaterfall.pptx`, 'ChartWaterfall')
+    .load(`ChartBarsStacked.pptx`, 'ChartBarsStacked');
 
-  ppt.addSlide('charts', 1);
-  ppt.addSlide('charts', 2);
-  ppt.addSlide('images', 1);
-  ppt.addSlide('images', 2);
+  const result = await pres
+    .addSlide('EmptySlide', 1, (slide) => {
+      // slide.addElement('ChartBarsStacked', 1, 'BarsStacked', [
+      //   modify.setChartData(<ChartData>{
+      //     series: [{ label: 'series 1' }],
+      //     categories: [
+      //       { label: 'cat 2-1', values: [50] },
+      //       { label: 'cat 2-2', values: [14] },
+      //       { label: 'cat 2-3', values: [15] },
+      //       { label: 'cat 2-4', values: [26] },
+      //     ],
+      //   }),
+      // ]);
 
-  ppt.modify(ModifyPresentationHelper.sortSlides([3, 2, 1]));
-
-  const summary = await ppt.write('reorder.pptx');
+      slide.addElement('ChartWaterfall', 1, 'Waterfall 1', [
+        modify.setExtendedChartData(<ChartData>{
+          series: [{ label: 'series 1' }],
+          categories: [
+            { label: 'cat 2-1', values: [50] },
+            { label: 'cat 2-2', values: [14] },
+            { label: 'cat 2-3', values: [15] },
+            { label: 'cat 2-4', values: [26] },
+            { label: 'cat 2-4', values: [26] },
+            { label: 'cat 2-4', values: [26] },
+            { label: 'cat 2-4', values: [26] },
+            { label: 'cat 2-4', values: [26] },
+          ],
+        }),
+      ]);
+    })
+    .write(`modify-existing-waterfall-chart.test.pptx`);
 };
 
 run().catch((error) => {

src/dev.ts

@@ -3,3 +3,8 @@ export enum ElementType {
   Image = 'Image',
   Shape = 'Generic',
 }
+
+export enum ElementSubtype {
+  chart = 'chart',
+  chartEx = 'chartEx',
+}

src/enums/element-type.ts

@@ -29,9 +29,15 @@ export class FileHelper {
     return archive.files[file].async(type || 'string');
   }
 
+  static fileExistsInArchive(archive: JSZip, file: string): boolean {
+    if (archive === undefined || archive.files[file] === undefined) {
+      return false;
+    }
+  }
+
   static extractFileContent(file: Buffer): Promise<JSZip> {
     const zip = new JSZip();
-    return zip.loadAsync((file as unknown) as InputType);
+    return zip.loadAsync(file as unknown as InputType);
   }
 
   static getFileExtension(filename: string): string {

src/helper/file-helper.ts

@@ -206,6 +206,33 @@ export default class ModifyChartHelper {
       // XmlHelper.dump(chart)
     };
 
+  /**
+   * Set chart data to modify extended chart types.
+   * See `__tests__/modify-existing-extended-chart.test.js`
+   */
+  static setExtendedChartData =
+    (data: ChartData) =>
+    (
+      element: XMLDocument | Element,
+      chart?: Document,
+      workbook?: Workbook,
+    ): void => {
+      const slots = [] as ChartSlot[];
+      data.series.forEach((series: ChartSeries, s: number) => {
+        slots.push({
+          index: s,
+          series: series,
+          targetCol: s + 1,
+          type: 'extendedSeries',
+        });
+      });
+
+      new ModifyChart(chart, workbook, data, slots).modifyExtended();
+
+      XmlHelper.dump(chart);
+      // XmlHelper.dump(workbook.table)
+    };
+
   static setAxisRange =
     (range: ChartAxisRange) =>
     (chart: XMLDocument): void => {

src/helper/modify-chart-helper.ts

@@ -116,13 +116,23 @@ export default class ModifyXmlHelper {
   static value =
     (value: number | string, index?: number) =>
     (element: Element): void => {
-      element.getElementsByTagName('c:v')[0].firstChild.textContent =
-        String(value);
+      const valueElement = element.getElementsByTagName('c:v');
+      if (!valueElement.length) {
+        XmlHelper.dump(element);
+        throw 'Unable to set value @index: ' + index;
+      }
+
+      valueElement[0].firstChild.textContent = String(value);
       if (index !== undefined) {
         element.setAttribute('idx', String(index));
       }
     };
 
+  static textContent =
+    (value: number | string) =>
+    (element: Element): void => {
+      element.firstChild.textContent = String(value);
+    };
   static attribute =
     (attribute: string, value: string | number) =>
     (element: Element): void => {

src/helper/modify-xml-helper.ts

@@ -4,19 +4,15 @@ import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
 import { FileHelper } from './file-helper';
 import {
   DefaultAttribute,
+  HelperElement,
   OverrideAttribute,
   RelationshipAttribute,
-  HelperElement,
   ModifyXmlCallback,
 } from '../types/xml-types';
 import { TargetByRelIdMap } from '../constants/constants';
 import { XmlPrettyPrint } from './xml-pretty-print';
-import {
-  GetRelationshipsCallback,
-  SourceSlideIdentifier,
-  Target,
-} from '../types/types';
-import { XmlTemplateHelper } from './xml-template-helper';
+import { GetRelationshipsCallback, Target } from '../types/types';
+import _ from 'lodash';
 import { vd } from './general-helper';
 
 export class XmlHelper {
@@ -142,26 +138,50 @@ export class XmlHelper {
     return max;
   }
 
+  static pushRelTargets(element: Element, prefix: string, targets: Target[]) {
+    const type = element.getAttribute('Type');
+    const target = element.getAttribute('Target');
+    const rId = element.getAttribute('Id');
+
+    const subtype = _.last(prefix.split('/'));
+    const relType = _.last(type.split('/'));
+
+    const matchNumber = target.match(/(\d+)/);
+    const stripNumber =
+      matchNumber && matchNumber[1] ? Number(matchNumber[1]) : 0;
+
+    if (XmlHelper.targetMatchesRelationship(relType, subtype, target, prefix)) {
+      targets.push({
+        file: target,
+        rId: rId,
+        number: stripNumber,
+        type: type,
+        subtype: subtype,
+      } as Target);
+    }
+  }
+
+  static targetMatchesRelationship(relType, subtype, target, prefix) {
+    if (relType === 'package') return true;
+
+    return relType === subtype && target.indexOf(prefix) === 0;
+  }
+
   static async getTargetsFromRelationships(
     archive: JSZip,
     path: string,
-    prefix: string,
+    prefix: string | string[],
     suffix?: string | RegExp,
   ): Promise<Target[]> {
+    const prefixes = typeof prefix === 'string' ? [prefix] : prefix;
+
     return XmlHelper.getRelationships(
       archive,
       path,
-      (element: Element, rels: Target[]) => {
-        const target = element.getAttribute('Target');
-        if (target.indexOf(prefix) === 0) {
-          rels.push({
-            file: target,
-            rId: element.getAttribute('Id'),
-            number: Number(
-              target.replace(prefix, '').replace(suffix || '.xml', ''),
-            ),
-          } as Target);
-        }
+      (element: Element, targets: Target[]) => {
+        prefixes.forEach((prefix) => {
+          XmlHelper.pushRelTargets(element, prefix, targets);
+        });
       },
     );
   }