officeparser 4.0.4 → 4.0.6

package/README.md

@@ -13,6 +13,7 @@ A Node.js library to parse text out of any office file.
 
 
 #### Update
+* 2023/11/25 - Fixed error catching when an error occurs within the parsing of a file, especially after decompressing it. Also fixed the problem with parallel parsing of files as we were using only timestamp in file names.
 * 2023/10/24 - Revamped content parsing code. Fixed order of content in files, especially in word files where table information would always land up at the end of the text. Added config object as argument for parseOffice which can be used to set new line delimiter and multiple other configurations. Added support for parsing pdf files using the popular npm library pdf-parse. Removed support for individual file parsing functions.
 * 2023/04/26 - Added support for file buffers as argument for filepath for parseOffice and parseOfficeAsync
 * 2023/04/07 - Added typings to methods to help with Typescript projects.
@@ -95,14 +96,15 @@ officeParser.parseOfficeAsync(fileBuffers);
 
 ### Configuration Object: OfficeParserConfig
 *Optionally add a config object as 3rd variable to parseOffice for the following configurations*
-| flag                 | datatype | explanation                                                                                                                                                                                                                                     |
-|----------------------|----------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| tempFilesLocation    | string   | The directory where officeparser stores the temp files . The final decompressed data will be put inside officeParserTemp folder within your directory. **Please ensure that this directory actually exists.** Default is officeParsertemp.      |
-| preserveTempFiles    | boolean  | Flag to not delete the internal content files and the possible duplicate temp files that it uses after unzipping office files. Default is false. It always deletes all of those files.                                                          |
-| outputErrorToConsole | boolean  | Flag to show all the logs to console in case of an error.                                                                                                                                                                                       |
-| newlineDelimiter     | string   | The delimiter used for every new line in places that allow multiline text like word. Default is \n.                                                                                                                                             |
-| ignoreNotes          | boolean  | Flag to ignore notes from parsing in files like powerpoint. Default is false. It includes notes in the parsed text by default.                                                                                                                  |
-| putNotesAtLast       | boolean  | Flag, if set to true, will collectively put all the parsed text from notes at last in files like powerpoint. Default is false. It puts each notes right after its main slide content. If ignoreNotes is set to true, this flag is also ignored. |
+| Flag                 | DataType | Default          | Explanation                                                                                                                                                                                                                                     |
+|----------------------|----------|------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| tempFilesLocation    | string   | officeParserTemp | The directory where officeparser stores the temp files . The final decompressed data will be put inside officeParserTemp folder within your directory. **Please ensure that this directory actually exists.** Default is officeParserTemp.      |
+| preserveTempFiles    | boolean  | false            | Flag to not delete the internal content files and the possible duplicate temp files that it uses after unzipping office files. Default is false. It always deletes all of those files.                                                          |
+| outputErrorToConsole | boolean  | false            | Flag to show all the logs to console in case of an error. Default is false.                                                                                                                                                                     |
+| newlineDelimiter     | string   | \n               | The delimiter used for every new line in places that allow multiline text like word. Default is \n.                                                                                                                                             |
+| ignoreNotes          | boolean  | false            | Flag to ignore notes from parsing in files like powerpoint. Default is false. It includes notes in the parsed text by default.                                                                                                                  |
+| putNotesAtLast       | boolean  | false            | Flag, if set to true, will collectively put all the parsed text from notes at last in files like powerpoint. Default is false. It puts each notes right after its main slide content. If ignoreNotes is set to true, this flag is also ignored. |
+<br>
 
 ```js
 const config = {
@@ -121,8 +123,8 @@ officeParser.parseOffice("/path/to/officeFile", function(data, err){
 
 // promise
 officeParser.parseOfficeAsync("/path/to/officeFile", config);
-    .then((data) => console.log(data))
-    .catch((err) => console.error(err))
+    .then(data => console.log(data))
+    .catch(err => console.error(err))
 ```
 
 **Example - JavaScript**
@@ -140,7 +142,7 @@ officeParser.parseOfficeAsync("/Users/harsh/Desktop/files/mySlides.pptx", config
         const newText = data + " look, I can parse a powerpoint file";
         callSomeOtherFunction(newText);
     })
-    .catch((err) => console.error(err));
+    .catch(err => console.error(err));
 
 // Search for a term in the parsed text.
 function searchForTermInOfficeFile(searchterm, filepath) {
@@ -165,10 +167,10 @@ officeParser.parseOfficeAsync("/Users/harsh/Desktop/files/mySlides.pptx", config
         const newText = data + " look, I can parse a powerpoint file";
         callSomeOtherFunction(newText);
     })
-    .catch((err) => console.error(err));
+    .catch(err => console.error(err));
 
 // Search for a term in the parsed text.
-function searchForTermInOfficeFile(searchterm, filepath): Promise<boolean> {
+function searchForTermInOfficeFile(searchterm: string, filepath: string): Promise<boolean> {
     return officeParser.parseOfficeAsync(filepath)
         .then(data => data.indexOf(searchterm) != -1)
 }

package/officeParser.js

@@ -69,10 +69,11 @@ function parseWord(filepath, callback, config) {
         { filter: x => [mainContentFile, footnotesFile, endnotesFile].includes(x.path) }
     )
     .then(files => {
-        if (files.length == 0)
+        // Verify if atleast the document xml file exists in the extracted files list.
+        if (!files.map(file => file.path).includes(mainContentFile))
             throw ERRORMSG.fileCorrupted(filepath);
 
-        return [...files.filter(file => file.path == mainContentFile), 
+        return [...files.filter(file => file.path == mainContentFile),
                     ...files.filter(file => file.path == footnotesFile),
                     ...files.filter(file => file.path == endnotesFile)
                     ]
@@ -99,7 +100,10 @@ function parseWord(filepath, callback, config) {
                         // Find text nodes with w:t tags
                         const xmlTextNodeList = paragraphNode.getElementsByTagName("w:t");
                         // Join the texts within this paragraph node without any spaces or delimiters.
-                        return Array.from(xmlTextNodeList).map(textNode => textNode.childNodes[0].nodeValue).join("");
+                        return Array.from(xmlTextNodeList)
+                                .filter(textNode => textNode.childNodes[0] && textNode.childNodes[0].nodeValue)
+                                .map(textNode => textNode.childNodes[0].nodeValue)
+                                .join("");
                     })
                     // Join each paragraph text with a new line delimiter.
                     .join(config.newlineDelimiter ?? "\n")
@@ -132,8 +136,8 @@ function parsePowerPoint(filepath, callback, config) {
         { filter: x => x.path.match(config.ignoreNotes ? slidesRegex : allFilesRegex) }
     )
     .then(files => {
-        // Check if files is corrupted
-        if (files.length == 0)
+        // Verify if atleast the slides xml files exist in the extracted files list.
+        if (files.length == 0 || !files.map(file => file.path).some(filename => filename.match(slidesRegex)))
             throw ERRORMSG.fileCorrupted(filepath);
 
         // Check if any sorting is required.
@@ -166,7 +170,10 @@ function parsePowerPoint(filepath, callback, config) {
                     .map(paragraphNode => {
                         /** Find text nodes with a:t tags */
                         const xmlTextNodeList = paragraphNode.getElementsByTagName("a:t");
-                        return Array.from(xmlTextNodeList).map(textNode => textNode.childNodes[0].nodeValue).join("");
+                        return Array.from(xmlTextNodeList)
+                                .filter(textNode => textNode.childNodes[0] && textNode.childNodes[0].nodeValue)
+                                .map(textNode => textNode.childNodes[0].nodeValue)
+                                .join("");
                     })
                     .join(config.newlineDelimiter ?? "\n")
             );
@@ -200,7 +207,8 @@ function parseExcel(filepath, callback, config) {
         { filter: x => ([sheetsRegex, drawingsRegex, chartsRegex].findIndex(fileRegex => x.path.match(fileRegex)) > -1) || (x.path == stringsFilePath )}
     )
     .then(files => {
-        if (files.length == 0)
+        // Verify if atleast the slides xml files exist in the extracted files list.
+        if (files.length == 0 || !files.map(file => file.path).some(filename => filename.match(sheetsRegex)))
             throw ERRORMSG.fileCorrupted(filepath);
 
         return {
@@ -225,7 +233,9 @@ function parseExcel(filepath, callback, config) {
         /** Find text nodes with t tags in sharedStrings xml file */
         const sharedStringsXmlTNodesList = parseString(xmlContentFilesObject.sharedStringsFile).getElementsByTagName("t");
         /** Create shared string array. This will be used as a map to get strings from within sheet files. */
-        const sharedStrings = Array.from(sharedStringsXmlTNodesList).map(tNode => tNode.childNodes[0].nodeValue);
+        const sharedStrings = Array.from(sharedStringsXmlTNodesList)
+                                .filter(tNode => tNode.childNodes[0] && tNode.childNodes[0].nodeValue)
+                                .map(tNode => tNode.childNodes[0].nodeValue);
 
         // Parse Sheet files
         xmlContentFilesObject.sheetFiles.forEach(sheetXmlContent => {
@@ -234,8 +244,10 @@ function parseExcel(filepath, callback, config) {
             // Traverse through the nodes list and fill responseText with either the number value in its v node or find a mapped string from sharedStrings.
             responseText.push(
                 Array.from(sheetsXmlCNodesList)
-                    // Filter c nodes than do not have any v nodes
-                    .filter(cNode => cNode.getElementsByTagName("v").length != 0)
+                    // Filter c nodes than do not have any valid v nodes
+                    .filter(cNode => cNode.getElementsByTagName("v")[0]
+                                        && cNode.getElementsByTagName("v")[0].childNodes[0]
+                                        && cNode.getElementsByTagName("v")[0].childNodes[0].nodeValue)
                     .map(cNode => {
                         /** Flag whether this node's value represents a string index */
                         const isString = cNode.getAttribute("t") == "s";
@@ -266,7 +278,10 @@ function parseExcel(filepath, callback, config) {
                     .map(paragraphNode => {
                         /** Find text nodes with a:t tags */
                         const xmlTextNodeList = paragraphNode.getElementsByTagName("a:t");
-                        return Array.from(xmlTextNodeList).map(textNode => textNode.childNodes[0].nodeValue).join("");
+                        return Array.from(xmlTextNodeList)
+                                .filter(textNode => textNode.childNodes[0] && textNode.childNodes[0].nodeValue)
+                                .map(textNode => textNode.childNodes[0].nodeValue)
+                                .join("");
                     })
                     .join(config.newlineDelimiter ?? "\n")
             );
@@ -279,6 +294,7 @@ function parseExcel(filepath, callback, config) {
             /** Store all the text content to respond */
             responseText.push(
                 Array.from(chartsXmlCVNodesList)
+                    .filter(cVNode => cVNode.childNodes[0] && cVNode.childNodes[0].nodeValue)
                     .map(cVNode => cVNode.childNodes[0].nodeValue)
                     .join(config.newlineDelimiter ?? "\n")
             );
@@ -311,7 +327,8 @@ function parseOpenOffice(filepath, callback, config) {
         { filter: x => x.path == mainContentFilePath || x.path.match(objectContentFilesRegex) }
     )
     .then(files => {
-        if (files.length == 0)
+        // Verify if atleast the content xml file exists in the extracted files list.
+        if (!files.map(file => file.path).includes(mainContentFilePath))
             throw ERRORMSG.fileCorrupted(filepath);
 
         return {
@@ -475,7 +492,7 @@ function parseOffice(file, callback, config = {}) {
                 .then(data =>
                 {
                     // temp file name
-                    const newfilepath = `${internalConfig.tempFilesLocation}/tempfiles/${new Date().getTime().toString()}.${data.ext.toLowerCase()}`;
+                    const newfilepath = getNewFileName(internalConfig.tempFilesLocation, data.ext.toLowerCase());
                     // write new file
                     fs.writeFileSync(newfilepath, file);
                     // resolve promise
@@ -492,7 +509,7 @@ function parseOffice(file, callback, config = {}) {
             throw ERRORMSG.fileDoesNotExist(file);
 
         // temp file name
-        const newfilepath = `${internalConfig.tempFilesLocation}/tempfiles/${new Date().getTime().toString()}.${file.split(".").pop().toLowerCase()}`;
+        const newfilepath = getNewFileName(internalConfig.tempFilesLocation, file.split(".").pop().toLowerCase());
         // Copy the file into a temp location with the temp name
         fs.copyFileSync(file, newfilepath)
         // resolve promise
@@ -538,16 +555,13 @@ function parseOffice(file, callback, config = {}) {
 
                 // Check if there is an error. Throw if there is an error.
                 if (err)
-                    throw err;
+                    return handleError(err, callback, internalConfig.outputErrorToConsole);
 
                 // Call the original callback
                 callback(data, undefined);
             }
         })
-        .catch(error => {
-            consoleError(error, internalConfig.outputErrorToConsole);
-            callback(undefined, ERRORHEADER + error);
-        });
+        .catch(error => handleError(error, callback, internalConfig.outputErrorToConsole));
 }
 
 /**
@@ -556,7 +570,7 @@ function parseOffice(file, callback, config = {}) {
  * @param {OfficeParserConfig} [config={}] [OPTIONAL]: Config Object for officeParser
  * @returns {Promise<string>}
  */
-function parseOfficeAsync (file, config = {}) {
+function parseOfficeAsync(file, config = {}) {
     return new Promise((res, rej) => {
         parseOffice(file, function (data, err) {
             if (err)
@@ -566,6 +580,40 @@ function parseOfficeAsync (file, config = {}) {
     });
 }
 
+/** Global file name iterator. */
+let globalFileNameIterator = 0;
+/**
+ * File Name generator that takes the extension as an input and returns a file name that comprises a timestamp and an incrementing number
+ * to allow the files to be sorted in chronological order
+ * @param {string} tempFilesLocation Directory whether this new file needs to be stored
+ * @param {string} ext               File extension for this new generated file name
+ * @returns {string} 
+ */
+function getNewFileName(tempFilesLocation, ext) {
+    // Get the iterator part of the file name
+    let iteratorPart = (globalFileNameIterator++).toString().padStart(5, '0');
+    // We want the iterator part of the file name to be of 5 digits.
+    // Therefore, when the iterator crosses into 6 digits, we reset it to 0.
+    if (globalFileNameIterator > 99999)
+        globalFileNameIterator = 0;
+
+    // Return the file name
+    return `${tempFilesLocation}/tempfiles/${new Date().getTime().toString() + iteratorPart}.${ext}`;
+}
+
+/**
+ * Handle error by logging it to console if permitted by the config.
+ * And after that, trigger the callback function with the error value.
+ * @param {string}   error                Error text
+ * @param {function} callback             Callback function provided by the caller
+ * @param {boolean}  outputErrorToConsole Flag to log error to console.
+ * @returns {void}
+ */
+function handleError(error, callback, outputErrorToConsole) {
+    consoleError(error, outputErrorToConsole);
+    callback(undefined, ERRORHEADER + error);
+}
+
 
 // Export functions
 module.exports.parseOffice      = parseOffice;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "officeparser",
-  "version": "4.0.4",
+  "version": "4.0.6",
   "description": "A Node.js library to parse text out of any office file. Currently supports docx, pptx, xlsx, odt, odp, ods, pdf files.",
   "main": "officeParser.js",
   "files": [