refactor(archive): use jszip to compress fs created folder

Author: singerla

src/automizer.ts

@@ -84,10 +84,15 @@ export default class Automizer implements IPresentationProps {
     if (params.presTemplates) {
       this.params.presTemplates.forEach((file) => {
         const location = this.getLocation(file, 'template');
+        const archiveParams = {
+          ...this.archiveParams,
+          name: file,
+        };
         const newTemplate = Template.import(
           location,
-          this.archiveParams,
+          archiveParams,
         ) as PresTemplate;
+
         this.templates.push(newTemplate);
       });
     }

src/dev.ts

@@ -11,17 +11,23 @@ const automizer = new Automizer({
     workDir: outputName,
     cleanupWorkDir: true,
   },
+  rootTemplate: 'RootTemplateWithImages.pptx',
+  presTemplates: [
+    `RootTemplate.pptx`,
+    `SlideWithImages.pptx`,
+    `ChartBarsStacked.pptx`,
+  ],
   removeExistingSlides: true,
   cleanup: true,
-  compression: 5,
+  compression: 0,
 });
 
 const run = async () => {
-  const pres = automizer
-    .loadRoot(`RootTemplateWithImages.pptx`)
-    .load(`RootTemplate.pptx`, 'root')
-    .load(`SlideWithImages.pptx`, 'images')
-    .load(`ChartBarsStacked.pptx`, 'charts');
+  // const pres = automizer
+  //   .loadRoot(`RootTemplateWithImages.pptx`)
+  //   .load(`RootTemplate.pptx`, 'root')
+  //   .load(`SlideWithImages.pptx`, 'images')
+  //   .load(`ChartBarsStacked.pptx`, 'charts');
 
   const dataSmaller = {
     series: [{ label: 'series s1' }, { label: 'series s2' }],
@@ -31,27 +37,25 @@ const run = async () => {
     ],
   };
 
-  const result = await pres
-    .addSlide('charts', 1, (slide) => {
+  const result = await automizer
+    .addSlide('ChartBarsStacked.pptx', 1, (slide) => {
       slide.modifyElement('BarsStacked', [modify.setChartData(dataSmaller)]);
-      slide.addElement('charts', 1, 'BarsStacked', [
+      slide.addElement('ChartBarsStacked.pptx', 1, 'BarsStacked', [
         modify.setChartData(dataSmaller),
       ]);
     })
-    .addSlide('images', 1)
-    .addSlide('root', 1, (slide) => {
-      slide.addElement('charts', 1, 'BarsStacked', [
+    .addSlide('SlideWithImages.pptx', 1)
+    .addSlide('RootTemplate.pptx', 1, (slide) => {
+      slide.addElement('ChartBarsStacked.pptx', 1, 'BarsStacked', [
         modify.setChartData(dataSmaller),
       ]);
     })
-    .addSlide('charts', 1, (slide) => {
-      slide.addElement('images', 2, 'imageJPG');
+    .addSlide('ChartBarsStacked.pptx', 1, (slide) => {
+      slide.addElement('SlideWithImages.pptx', 2, 'imageJPG');
       slide.modifyElement('BarsStacked', [modify.setChartData(dataSmaller)]);
     })
-    .addSlide('charts', 1, (slide) => {
-      slide.addElement('images', 2, 'imageJPG');
-      slide.addElement('images', 2, 'imageSVG');
-      slide.addElement('images', 2, 'imageSVG');
+    .addSlide('ChartBarsStacked.pptx', 1, (slide) => {
+      slide.addElement('SlideWithImages.pptx', 2, 'imageJPG');
       slide.modifyElement('BarsStacked', [modify.setChartData(dataSmaller)]);
     })
     .write(outputName);

src/helper/archive/archive-fs.ts

@@ -1,7 +1,7 @@
 import Archive from './archive';
 import fs, { promises as fsPromises } from 'fs';
 import JSZip, { InputType } from 'jszip';
-import { ArchiveParams } from '../../types/types';
+import { ArchiveParams, AutomizerParams } from '../../types/types';
 import IArchive, { ArchivedFile } from '../../interfaces/iarchive';
 import { XmlDocument } from '../../types/xml-types';
 import ArchiveJszip from './archive-jszip';
@@ -14,6 +14,7 @@ import {
 } from '../file-helper';
 import { vd } from '../general-helper';
 import extract from 'extract-zip';
+import { compressFolder } from '../jszip-helper';
 
 export default class ArchiveFs extends Archive implements IArchive {
   archive: boolean;
@@ -143,18 +144,19 @@ export default class ArchiveFs extends Archive implements IArchive {
     }
   }
 
-  async output(location: string): Promise<void> {
+  async output(location: string, params: AutomizerParams): Promise<void> {
     await this.writeBuffer(this);
+    this.setOptions(params);
 
-    let exec = require('child_process').exec;
-    const command = `(cd ${this.workDir} && zip -r - .) > ${location}`;
-    const script = await exec(command);
+    if (exists(location)) {
+      await fsPromises.rm(location);
+    }
 
-    script.on('exit', async (code) => {
-      if (this.params.cleanupWorkDir === true) {
-        await this.cleanupWorkDir();
-      }
-    });
+    await compressFolder(this.workDir, location, this.options);
+
+    if (this.params.cleanupWorkDir === true) {
+      await this.cleanupWorkDir();
+    }
   }
 
   async cleanupWorkDir(): Promise<void> {

src/helper/archive/archive-jszip.ts

@@ -1,16 +1,14 @@
 import Archive from './archive';
-import fs from 'fs';
+import fs, { promises as fsp } from 'fs';
 import JSZip, { InputType } from 'jszip';
 import { AutomizerParams } from '../../types/types';
 import IArchive, { ArchivedFile } from '../../interfaces/iarchive';
 import { XmlDocument } from '../../types/xml-types';
+import path from 'path';
 
 export default class ArchiveJszip extends Archive implements IArchive {
   archive: JSZip;
   file: Buffer;
-  options: JSZip.JSZipGeneratorOptions<'nodebuffer'> = {
-    type: 'nodebuffer',
-  };
 
   constructor(filename) {
     super(filename);
@@ -93,15 +91,6 @@ export default class ArchiveJszip extends Archive implements IArchive {
     return (await this.archive.generateAsync(this.options)) as Buffer;
   }
 
-  private setOptions(params: AutomizerParams): void {
-    if (params.compression > 0) {
-      this.options.compression = 'DEFLATE';
-      this.options.compressionOptions = {
-        level: params.compression,
-      };
-    }
-  }
-
   async readXml(file: string): Promise<XmlDocument> {
     const isBuffered = this.fromBuffer(file);
 

src/helper/archive/archive.ts

@@ -1,10 +1,15 @@
 import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
 import { ArchivedFile, ArchiveType } from '../../interfaces/iarchive';
 import { XmlDocument } from '../../types/xml-types';
+import { AutomizerParams } from '../../types/types';
+import JSZip from 'jszip';
 
 export default class Archive {
   filename: string;
   buffer: ArchivedFile[] = [];
+  options: JSZip.JSZipGeneratorOptions<'nodebuffer'> = {
+    type: 'nodebuffer',
+  };
 
   constructor(filename) {
     this.filename = filename;
@@ -42,4 +47,13 @@ export default class Archive {
   fromBuffer(relativePath) {
     return this.buffer.find((file) => file.relativePath === relativePath);
   }
+
+  setOptions(params: AutomizerParams): void {
+    if (params.compression > 0) {
+      this.options.compression = 'DEFLATE';
+      this.options.compressionOptions = {
+        level: params.compression,
+      };
+    }
+  }
 }

src/helper/jszip-helper.ts

@@ -0,0 +1,68 @@
+import fs, { promises as fsp } from 'fs';
+import path from 'path';
+import JSZip from 'jszip';
+
+// Thanks to https://github.com/DesignByOnyx
+// see https://github.com/Stuk/jszip/issues/386 for more info
+
+/**
+ * Returns a flat list of all files and subfolders for a directory (recursively).
+ * @param {string} dir
+ * @returns {Promise<string[]>}
+ */
+const getFilePathsRecursively = async (dir) => {
+  // returns a flat array of absolute paths of all files recursively contained in the dir
+  const list = await fsp.readdir(dir);
+  const statPromises = list.map(async (file) => {
+    const fullPath = path.resolve(dir, file);
+    const stat = await fsp.stat(fullPath);
+    if (stat && stat.isDirectory()) {
+      return getFilePathsRecursively(fullPath);
+    }
+    return fullPath;
+  });
+
+  return (await Promise.all(statPromises)).flat(Infinity);
+};
+
+/**
+ * Creates an in-memory zip stream from a folder in the file system
+ * @param {string} dir
+ * @returns {JSZip}
+ */
+const createZipFromFolder = async (dir) => {
+  const absRoot = path.resolve(dir);
+  const filePaths = await getFilePathsRecursively(dir);
+  return filePaths.reduce((z, filePath) => {
+    const relative = filePath.replace(absRoot, '');
+    // create folder trees manually :(
+    const zipFolder = path
+      .dirname(relative)
+      .split(path.sep)
+      .reduce((zf, dirName) => zf.folder(dirName), z);
+
+    zipFolder.file(path.basename(filePath), fs.createReadStream(filePath));
+    return z;
+  }, new JSZip());
+};
+
+/**
+ * Compresses a folder to the specified zip file.
+ * @param {string} srcDir
+ * @param {string} destFile
+ */
+export const compressFolder = async (srcDir, destFile, options) => {
+  const start = Date.now();
+  try {
+    const zip = await createZipFromFolder(srcDir);
+    zip
+      .generateNodeStream({ streamFiles: true, ...options })
+      .pipe(fs.createWriteStream(destFile))
+      .on('error', (err) => console.error('Error writing file', err.stack))
+      .on('finish', () =>
+        console.log('Zip written successfully:', Date.now() - start, 'ms'),
+      );
+  } catch (ex) {
+    console.error('Error creating zip', ex);
+  }
+};

src/helper/modify-presentation-helper.ts

@@ -99,17 +99,12 @@ export default class ModifyPresentationHelper {
     await Tracker.collect('ppt/slideMasters', 'image', keepFiles);
     await Tracker.collect('ppt/slideLayouts', 'image', keepFiles);
 
-    const removed = await FileHelper.removeFromDirectory(
-      archive,
-      'ppt/media',
-      (file) => {
-        const info = FileHelper.getFileInfo(file.name);
-        return (
-          extensions.includes(info.extension.toLowerCase()) &&
-          !keepFiles.includes(info.base)
-        );
-      },
-    );
-    vd(removed);
+    await FileHelper.removeFromDirectory(archive, 'ppt/media', (file) => {
+      const info = FileHelper.getFileInfo(file.name);
+      return (
+        extensions.includes(info.extension.toLowerCase()) &&
+        !keepFiles.includes(info.base)
+      );
+    });
   }
 }