Merge pull request #31 from singerla/feature-modify-presentation

Feature modify presentation

Author: singerla

__tests__/sort-slides.test.ts

@@ -0,0 +1,30 @@
+import Automizer from '../src/automizer';
+import ModifyPresentationHelper from '../src/helper/modify-presentation-helper';
+
+test('read root presentation and sort slides', async () => {
+  const automizer = new Automizer({
+    templateDir: `${__dirname}/pptx-templates`,
+    outputDir: `${__dirname}/pptx-output`,
+  });
+  const pres = automizer
+    .loadRoot(`RootTemplate.pptx`)
+    .load(`SlideWithShapes.pptx`, 'shapes')
+    .load(`SlideWithCharts.pptx`, 'charts')
+    .load(`SlideWithImages.pptx`, 'images');
+
+  for (let i = 0; i <= 2; i++) {
+    pres.addSlide('shapes', 1);
+  }
+
+  pres.addSlide('charts', 1);
+  pres.addSlide('charts', 2);
+  pres.addSlide('images', 1);
+  pres.addSlide('images', 2);
+
+  const order = [2, 1, 8, 7, 5, 6, 3, 4];
+  pres.modify(ModifyPresentationHelper.sortSlides(order));
+
+  await pres.write(`sort-slides.test.pptx`);
+
+  expect(pres).toBeInstanceOf(Automizer);
+});

src/automizer.ts

@@ -10,11 +10,13 @@ import { IPresentationProps } from './interfaces/ipresentation-props';
 import { PresTemplate } from './interfaces/pres-template';
 import { RootPresTemplate } from './interfaces/root-pres-template';
 import { Template } from './classes/template';
-import { TemplateInfo } from './types/xml-types';
+import { ModifyXmlCallback, TemplateInfo } from './types/xml-types';
 import { vd } from './helper/general-helper';
 import { Master } from './classes/master';
 import path from 'path';
 import * as fs from 'fs';
+import { XmlHelper } from './helper/xml-helper';
+import ModifyPresentationHelper from './helper/modify-presentation-helper';
 
 /**
  * Automizer
@@ -40,12 +42,15 @@ export default class Automizer implements IPresentationProps {
   params: AutomizerParams;
   status: StatusTracker;
 
+  modifyPresentation: ModifyXmlCallback[];
+
   /**
    * Creates an instance of `pptx-automizer`.
    * @param [params]
    */
   constructor(params: AutomizerParams) {
     this.templates = [];
+    this.modifyPresentation = [];
     this.params = params;
 
     this.templateDir = params?.templateDir ? params.templateDir + '/' : '';
@@ -157,7 +162,7 @@ export default class Automizer implements IPresentationProps {
   /**
    * Parses all loaded templates and collects creationIds for slides and
    * elements. This will make finding templates and elements independent
-   * from slide number and element name.
+   * of slide number and element name.
    * @returns Promise<TemplateInfo[]>
    */
   public async setCreationIds(): Promise<TemplateInfo[]> {
@@ -173,6 +178,11 @@ export default class Automizer implements IPresentationProps {
     return templateCreationId;
   }
 
+  public modify(cb: ModifyXmlCallback): this {
+    this.modifyPresentation.push(cb);
+    return this;
+  }
+
   /**
    * Determines whether template is root or default template.
    * @param template
@@ -262,8 +272,24 @@ export default class Automizer implements IPresentationProps {
    * @returns summary object.
    */
   public async write(location: string): Promise<AutomizerSummary> {
+    await this.writeSlides();
+    await this.normalizePresentation();
+    await this.applyModifyPresentationCallbacks();
+
     const rootArchive = await this.rootTemplate.archive;
+    const content = await rootArchive.generateAsync({ type: 'nodebuffer' });
+
+    return FileHelper.writeOutputFile(
+      this.getLocation(location, 'output'),
+      content,
+      this,
+    );
+  }
 
+  /**
+   * Write all slides into archive.
+   */
+  public async writeSlides(): Promise<void> {
     await this.rootTemplate.countExistingSlides();
     this.status.max = this.rootTemplate.slides.length;
 
@@ -274,16 +300,32 @@ export default class Automizer implements IPresentationProps {
     if (this.params.removeExistingSlides) {
       await this.rootTemplate.truncate();
     }
+  }
 
-    const content = await rootArchive.generateAsync({ type: 'nodebuffer' });
-
-    return FileHelper.writeOutputFile(
-      this.getLocation(location, 'output'),
-      content,
-      this,
+  /**
+   * Applies all callbacks in this.modifyPresentation-array.
+   * The callback array can be pushed by this.modify()
+   */
+  async applyModifyPresentationCallbacks(): Promise<void> {
+    await XmlHelper.modifyXmlInArchive(
+      this.rootTemplate.archive,
+      `ppt/presentation.xml`,
+      this.modifyPresentation,
     );
   }
 
+  /**
+   * Apply some callbacks to restore archive/xml structure
+   * and prevent corrupted pptx files.
+   *
+   * TODO: Remove unused parts (slides, related items) from archive.
+   * TODO: Use every imported image only once
+   * TODO: Check for lost relations
+   */
+  normalizePresentation(): void {
+    this.modify(ModifyPresentationHelper.normalizeSlideIds);
+  }
+
   /**
    * Applies path prefix to given location string.
    * @param location path and/or filename

src/classes/slide.ts

@@ -631,13 +631,6 @@ export class Slide implements ISlide {
       parent: (xml: XMLDocument) => xml.getElementsByTagName('p:sldIdLst')[0],
       tag: 'p:sldId',
       attributes: {
-        id: (xml: XMLDocument) =>
-          XmlHelper.getMaxId(
-            xml.getElementsByTagName('p:sldId'),
-            'id',
-            true,
-            256,
-          ),
         'r:id': relId,
       } as SlideListAttribute,
     });

src/dev.ts

@@ -1,5 +1,12 @@
-import Automizer, { ChartData, modify, TableRow, TableRowStyle } from './index';
+import Automizer, {
+  ChartData,
+  modify,
+  TableRow,
+  TableRowStyle,
+  XmlHelper,
+} from './index';
 import { vd } from './helper/general-helper';
+import ModifyPresentationHelper from './helper/modify-presentation-helper';
 
 const automizer = new Automizer({
   templateDir: `${__dirname}/../__tests__/pptx-templates`,
@@ -8,21 +15,19 @@ const automizer = new Automizer({
 });
 
 const run = async () => {
-  const pres = automizer
+  const ppt = automizer
     .loadRoot(`RootTemplate.pptx`)
     .load(`SlideWithCharts.pptx`, 'charts')
     .load(`SlideWithImages.pptx`, 'images');
 
-  const result = await pres
-    .addSlide('charts', 2, (slide) => {
-      slide.removeElement('ColumnChart');
-    })
-    .addSlide('images', 2, (slide) => {
-      slide.removeElement('imageJPG');
-      slide.removeElement('Textfeld 5');
-      slide.addElement('images', 2, 'imageJPG');
-    })
-    .write(`remove-element.test.pptx`);
+  ppt.addSlide('charts', 1);
+  ppt.addSlide('charts', 2);
+  ppt.addSlide('images', 1);
+  ppt.addSlide('images', 2);
+
+  ppt.modify(ModifyPresentationHelper.sortSlides([3, 2, 1]));
+
+  const summary = await ppt.write('reorder.pptx');
 };
 
 run().catch((error) => {

src/helper/modify-presentation-helper.ts

@@ -0,0 +1,34 @@
+import { XmlHelper } from './xml-helper';
+import { vd } from './general-helper';
+
+export default class ModifyPresentationHelper {
+  /**
+   * Get Collection of slides
+   */
+  static getSlidesCollection = (xml: XMLDocument) => {
+    return xml.getElementsByTagName('p:sldId');
+  };
+
+  /**
+   * Pass an array of slide numbers to define a target sort order.
+   * First slide starts by 1.
+   * @order Array of slide numbers, starting by 1
+   */
+  static sortSlides = (order: number[]) => (xml: XMLDocument) => {
+    const slides = ModifyPresentationHelper.getSlidesCollection(xml);
+    order.map((index, i) => order[i]--);
+    XmlHelper.sortCollection(slides, order);
+  };
+
+  /**
+   * Set ids to prevent corrupted pptx.
+   * Must start with 256 and increment by one.
+   */
+  static normalizeSlideIds = (xml: XMLDocument) => {
+    const slides = ModifyPresentationHelper.getSlidesCollection(xml);
+    const firstId = 256;
+    XmlHelper.modifyCollection(slides, (slide: Element, i) => {
+      slide.setAttribute('id', String(firstId + i));
+    });
+  };
+}

src/helper/xml-helper.ts

@@ -7,6 +7,7 @@ import {
   OverrideAttribute,
   RelationshipAttribute,
   HelperElement,
+  ModifyXmlCallback,
 } from '../types/xml-types';
 import { TargetByRelIdMap } from '../constants/constants';
 import { XmlPrettyPrint } from './xml-pretty-print';
@@ -19,6 +20,20 @@ import { XmlTemplateHelper } from './xml-template-helper';
 import { vd } from './general-helper';
 
 export class XmlHelper {
+  static async modifyXmlInArchive(
+    archive: Promise<JSZip>,
+    file: string,
+    callbacks: ModifyXmlCallback[],
+  ): Promise<JSZip> {
+    const xml = await XmlHelper.getXmlFromArchive(await archive, file);
+
+    for (const callback of callbacks) {
+      callback(xml);
+    }
+
+    return await XmlHelper.writeXmlToArchive(await archive, file, xml);
+  }
+
   static async getXmlFromArchive(
     archive: JSZip,
     file: string,
@@ -403,6 +418,39 @@ export class XmlHelper {
     }
   }
 
+  static sortCollection(
+    collection: HTMLCollectionOf<Element>,
+    order: number[],
+    callback?: ModifyXmlCallback,
+  ): void {
+    if (collection.length === 0) {
+      return;
+    }
+    const parent = collection[0].parentNode;
+    order.forEach((index, i) => {
+      if (!collection[index]) {
+        vd('sortCollection index not found' + index);
+        return;
+      }
+
+      const item = collection[index];
+      if (callback) {
+        callback(item, i);
+      }
+      parent.appendChild(item);
+    });
+  }
+
+  static modifyCollection(
+    collection: HTMLCollectionOf<Element>,
+    callback: ModifyXmlCallback,
+  ): void {
+    for (let i = 0; i < collection.length; i++) {
+      const item = collection[i];
+      callback(item, i);
+    }
+  }
+
   static dump(element: XMLDocument | Element): void {
     const s = new XMLSerializer();
     const xmlBuffer = s.serializeToString(element);

src/interfaces/itemplate.ts

@@ -4,4 +4,5 @@ export interface ITemplate {
   location: string;
   file: InputType;
   archive: Promise<JSZip>;
+  getSlideIdList: () => Promise<Document>;
 }

src/types/types.ts

@@ -29,6 +29,10 @@ export type AutomizerParams = {
    * You can set a path here.
    */
   outputDir?: string;
+  /**
+   * Buffer unzipped pptx on disk
+   */
+  cacheDir?: string;
   rootTemplate?: string;
   presTemplates?: string[];
   useCreationIds?: boolean;

src/types/xml-types.ts

@@ -62,3 +62,8 @@ export type ElementInfo = {
     cy: number;
   };
 };
+
+export type ModifyXmlCallback = (
+  xml: XMLDocument | Element,
+  index?: number,
+) => void;