officeparser 2.1.0 → 2.3.0

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "svn.ignoreMissingSvnWarning": true
+}

package/README.md

@@ -12,6 +12,8 @@ A Node.js library to parse text out of any office file.
 
 
 #### Update
+* 2021/11/21 - Added promise way to existing callback functions
+* 2020/06/01 - Added error handling and console.log enable/disable methods. Default is set at enabled. Everything backward compatible.
 * 2019/06/17 - Added method to change location for decompressing office files in places with restricted write access.
 * 2019/04/30 - Removed case sensitive file extension bug. File names with capital lettered extensions now supported.
 * 2019/04/23 - Added support for open office files *.odt, *.odp, *.ods through parseOffice function. Created a new method parseOpenOffice for those who prefer targetted functions. 
@@ -33,52 +35,125 @@ npm i officeparser
 ----------
 
 **Usage**
+```js
+const officeParser = require('officeparser');
+
+// callback
+officeParser.parseOffice("/path/to/officeFile", function(data, err){
+    // "data" string in the callback here is the text parsed from the office file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
+})
+
+// promise
+officeParser.parseOfficeAsync("/path/to/officeFile");
+// "data" string in the promise here is the text parsed from the office file passed in the argument above
+.then((data) => {
+    console.log(data)
+})
+.catch(err) => {
+    console.log(err)
+}
+
+// async/await
+try {
+    // "data" string returned from promise here is the text parsed from the office file passed in the argument
+    const data = await officeParser.parseOfficeAsync("/path/to/officeFile");
+    console.log(data);
+} catch (err) {
+    // resolve error
+    console.log(err);
+}
 ```
+
+**Please take note: I have breached convention in placing err as second argument in my callback but please understand that I had to do it to not break other people's existing modules.**
+
+*Optionally change decompression location for office Files at personalised locations for environments with restricted write access*
+
+```js
 const officeParser = require('officeparser');
 
 // Default decompress location for office Files is "officeDist" in the directory where Node is started. 
 // Put this file before parseOffice method to take effect.
 officeParser.setDecompressionLocation("/tmp");  // New decompression location would be "/tmp/officeDist"
 
-// P.S.: Setting location on a Windows environment with '\' heirarchy requires to be entered twice '\\'
+// P.S.: Setting location on a Windows environment with '\' hierarchy requires to be entered twice '\\'
 officeParser.setDecompressionLocation("C:\\tmp");  // New decompression location would be "C:\tmp\officeDist"
 
 
-officeParser.parseOffice("/path/to/officeFile", function(data){
-        // "data" string in the callback here is the text parsed from the office file passed in the first argument above
-        console.log(data)
+officeParser.parseOffice("/path/to/officeFile", function(data, err){
+    // "data" string in the callback here is the text parsed from the office file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
 })
-
 ```
 
 *Optionally add false as 3rd variable to parseOffice to not delete the generated officeDist folder*
 
-```
-officeParser.parseOffice("/path/to/officeFile", function(data){
-        // "data" string in the callback here is the text parsed from the office file passed in the first argument above
-        console.log(data)
+```js
+// callback
+officeParser.parseOffice("/path/to/officeFile", function(data, err){
+    if (err) return console.log(err);
+    console.log(data)
 }, false)
+
+// promise
+officeParser.parseOfficeAsync("/path/to/officeFile", false);
+.then((data) => {
+    console.log(data)
+})
+.catch(err) => {
+    console.log(err)
+}
+
+// async/await
+try {
+    const data = await officeParser.parseOfficeAsync("/path/to/officeFile", false);
+    console.log(data);
+} catch (err) {
+    // resolve error
+    console.log(err);
+}
 ```
 
 **Example**
-```
+```js
 const officeParser = require('officeparser');
 
-officeParser.parseOffice("C:\\files\\myText.docx", function(data){
-        var newText = data + "look, I can parse a word file"
-        callSomeOtherFunction(newText);
+// callback
+officeParser.parseOffice("C:\\files\\myText.docx", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse a word file"
+    callSomeOtherFunction(newText);
 })
 
-officeParser.parseOffice("/Users/harsh/Desktop/files/mySlides.pptx", function(data){
-        var newText = data + "look, I can parse a powerpoint file"
-        callSomeOtherFunction(newText);
+
+// promise
+officeParser.parseOfficeAsync("/Users/harsh/Desktop/files/mySlides.pptx");
+.then((data) => {
+    var newText = data + "look, I can parse a powerpoint file"
+    callSomeOtherFunction(newText);
 })
+.catch(err) => {
+    console.log(err)
+}
 
 // Using relative path for file is also fine
-officeParser.parseOffice("files/myWorkSheet.ods", function(data){
-        var newText = data + "look, I can parse an excel file"
-        callSomeOtherFunction(newText);
+officeParser.parseOffice("files/myWorkSheet.ods", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse an excel file"
+    callSomeOtherFunction(newText);
 })
+
+// async/await
+try {
+    const data = await officeParser.parseOfficeAsync("/Users/harsh/Desktop/files/mySlides.pptx");
+    let newText = data + "look, I can parse a powerpoint file";
+    await callSomeOtherFunction(newText);
+} catch (err) {
+    // resolve error
+    console.log(err);
+}
 ```
 
 
@@ -88,54 +163,158 @@ officeParser.parseOffice("files/myWorkSheet.ods", function(data){
 *These were the initial methods of parsing text till parseOffice method came into existence. These still exist and form the skeleton to this module as parseOffice redirects the below functions anyway. These functions will forever remain available to guarantee long-term usage of this module. I will ensure backward-compatibility with all previous versions.*
 
 **Usage**
-```
+```js
 const officeParser = require('officeparser');
 
-officeParser.parseWord("/path/to/word.docx", function(data){
-        // "data" string in the callback here is the text parsed from the word file passed in the first argument above
-        console.log(data)
+// callback
+officeParser.parseWord("/path/to/word.docx", function(data, err){
+    // "data" string in the callback here is the text parsed from the word file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
 })
 
-officeParser.parsePowerPoint("/path/to/powerpoint.pptx", function(data){
-        // "data" string in the callback here is the text parsed from the powerpoint file passed in the first argument above
-        console.log(data)
+officeParser.parsePowerPoint("/path/to/powerpoint.pptx", function(data, err){
+    // "data" string in the callback here is the text parsed from the powerpoint file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
 })
 
-officeParser.parseExcel("/path/to/excel.xlsx", function(data){
-        // "data" string in the callback here is the text parsed from the excel file passed in the first argument above
-        console.log(data)
+officeParser.parseExcel("/path/to/excel.xlsx", function(data, err){
+    // "data" string in the callback here is the text parsed from the excel file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
 })
 
-officeParser.parseOpenOffice("/path/to/writer.odt", function(data){
-        // "data" string in the callback here is the text parsed from the writer file passed in the first argument above
-        console.log(data)
+officeParser.parseOpenOffice("/path/to/writer.odt", function(data, err){
+    // "data" string in the callback here is the text parsed from the writer file passed in the first argument above
+    if (err) return console.log(err);
+    console.log(data)
 })
+
+// promise
+officeParser.parseWordAsync("/path/to/word.docx");
+.then((data) => {
+    // data is the parsed text
+})
+officeParser.parsePowerPointAsync("/path/to/powerpoint.pptx");
+.then((data) => {
+    // data is the parsed text
+})
+officeParser.parseExcelAsync("/path/to/excel.xlsx");
+.then((data) => {
+    // data is the parsed text
+})
+officeParser.parseOpenOfficeAsync("/path/to/writer.odt");
+.then((data) => {
+    // data is the parsed text
+})
+
+// async/await
+try {
+    // "data" string returned from promise here is the text parsed from the office file passed in the first argument
+    const data1 = await officeParser.parseWordAsync("/path/to/word.docx");
+
+    const data2 = await officeParser.parsePowerPointAsync("/path/to/powerpoint.pptx");
+
+    const data3 = await officeParser.parseExcelAsync("/path/to/excel.xlsx");
+
+    const data3 = await officeParser.parseOpenOfficeAsync("/path/to/writer.odt");
+} catch (err) {
+    // resolve error
+    console.log(err);
+}
 ```
 
 **Example**
-```
+```js
 const officeParser = require('officeparser');
 
-officeParser.parseWord("C:\\files\\myText.docx", function(data){
-        var newText = data + "look, I can parse a word file"
-        callSomeOtherFunction(newText);
+// callback
+officeParser.parseWord("C:\\files\\myText.docx", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse a word file"
+    callSomeOtherFunction(newText);
 })
 
-officeParser.parsePowerPoint("/Users/harsh/Desktop/files/mySlides.pptx", function(data){
-        var newText = data + "look, I can parse a powerpoint file"
-        callSomeOtherFunction(newText);
+officeParser.parsePowerPoint("/Users/harsh/Desktop/files/mySlides.pptx", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse a powerpoint file"
+    callSomeOtherFunction(newText);
 })
 
 // Using relative path for file is also fine
-officeParser.parseExcel("files/myWorkSheet.xlsx", function(data){
-        var newText = data + "look, I can parse an excel file"
-        callSomeOtherFunction(newText);
+officeParser.parseExcel("files/myWorkSheet.xlsx", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse an excel file"
+    callSomeOtherFunction(newText);
+})
+
+officeParser.parseOpenOffice("files/myDocument.odt", function(data, err){
+    if (err) return console.log(err);
+    var newText = data + "look, I can parse an OpenOffice file"
+    callSomeOtherFunction(newText);
 })
 
-officeParser.parseOpenOffice("files/myDocument.odt", function(data){
-        var newText = data + "look, I can parse an OpenOffice file"
-        callSomeOtherFunction(newText);
+// promise
+officeParser.parseWordAsync("C:\\files\\myText.docx");
+.then((data) => {
+    let newText1 = data1 + "look, I can parse a word file";
+    callSomeOtherFunction(newText1);
+})
+.catch(err) => {
+    console.log(err)
+}
+
+officeParser.parsePowerPointAsync("/Users/harsh/Desktop/files/mySlides.pptx");
+.then((data) => {
+    let newText2 = data2 + "look, I can parse a powerpoint file";
+    callSomeOtherFunction(newText2);
+})
+.catch(err) => {
+    console.log(err)
+}
+
+officeParser.parseExcelAsync("files/myWorkSheet.xlsx");
+.then((data) => {
+    let newText3 = data3 + "look, I can parse an excel file";
+    callSomeOtherFunction(newText3);
+})
+.catch(err) => {
+    console.log(err)
+}
+
+officeParser.parseOpenOfficeAsync("files/myDocument.odt");
+.then((data) => {
+    let newText4 = data4 + "look, I can parse an OpenOffice file";
+    callSomeOtherFunction(newText4);
 })
+.catch(err) => {
+    console.log(err)
+}
+
+
+// async/await
+try {
+    const data1 = await officeParser.parseWordAsync("C:\\files\\myText.docx");
+    let newText1 = data1 + "look, I can parse a word file";
+    await callSomeOtherFunction(newText1);
+
+    const data2 = await officeParser.parsePowerPointAsync("/Users/harsh/Desktop/files/mySlides.pptx");
+    let newText2 = data2 + "look, I can parse a powerpoint file";
+    await callSomeOtherFunction(newText2);
+
+    // Using relative path for file is also fine
+    const data3 = await officeParser.parseExcelAsync("files/myWorkSheet.xlsx");
+    let newText3 = data3 + "look, I can parse an excel file";
+    await callSomeOtherFunction(newText3);
+
+    const data4 = await officeParser.parseOpenOfficeAsync("files/myDocument.odt");
+    let newText4 = data4 + "look, I can parse an OpenOffice file";
+    await callSomeOtherFunction(newText4);
+} catch (err) {
+    // resolve error
+    console.log(err);
+}
 ```
 
 ----------

package/officeParser.js

@@ -8,6 +8,7 @@ const rimraf = require('rimraf');
 
 var myTextWord = [];
 var decompressLocation = "officeDist";
+var outputToConsoleWhenRequired = true;     // Default is set to true to let the user identify source of an error in node terminal
 
 async function scanForTextWord(result) {
     if (Array.isArray(result)) {
@@ -21,50 +22,59 @@ async function scanForTextWord(result) {
         }
         return;
     }
-    else if(typeof(result) == "object") {
+    else if (typeof(result) == "object") {
         for (var property in result) {
             if (result.hasOwnProperty(property)) {
-                if (typeof(result[property]) == "string"){
-                    if ((property == "w:t" || property == "_" ) && result[property] != "") {
+                if (typeof(result[property]) == "string") {
+                    if ((property == "w:t" || property == "_") && result[property] != "") {
                         await myTextWord.push(result[property]);
                     }
                 }
                 else {
                     await scanForTextWord(result[property]);
                 }
-                
             }
         }
         return;
     }
 }
 
-var parseWord = async function(filename, callback, deleteOfficeDist = true) {
+var parseWord = async function (filename, callback, deleteOfficeDist = true) {
     if (validateFileExtension(filename, ["docx"])) {
-        decompress(filename, decompressLocation).then(files => {
-            myTextWord = [];
-            if (fs.existsSync(decompressLocation + "/word/document.xml")) {
-                fs.readFile(decompressLocation + '/word/document.xml', 'utf8', function (err,data) {
-                    if (err) {
-                       return console.log(err);
-                     }
-                     
-                     xml2js.parseString(data, async function (err, result) {
-                        await scanForTextWord(result);
-        
-                        callback(myTextWord.join(" "));
-                        if (deleteOfficeDist == true) {
-                            rimraf(decompressLocation, function () {});
+        try {
+            decompress(filename, decompressLocation).then(files => {
+                myTextWord = [];
+                if (fs.existsSync(decompressLocation + "/word/document.xml")) {
+                    fs.readFile(decompressLocation + '/word/document.xml', 'utf8', function (err,data) {
+                        if (err) {
+                            if (outputToConsoleWhenRequired) console.log(err);
+                            return callback(undefined, err);
                         }
-                     });
-                 });
-            }
-            else {
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
+                        xml2js.parseString(data, async function (err, result) {
+                            await scanForTextWord(result);
+    
+                            callback(myTextWord.join(" "), undefined);
+                            if (deleteOfficeDist == true) {
+                                rimraf(decompressLocation, function () {});
+                            }
+                        });
+                    });
                 }
-            }
-        });
+                else {
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
+                    }
+                }
+            })
+            .catch(function (err) {
+                if (outputToConsoleWhenRequired) console.log(err);
+                return callback(undefined, err);
+            });
+        }
+        catch(err) {
+            if (outputToConsoleWhenRequired) console.log(err);
+            return callback(undefined, err);
+        }
     }
 }
 
@@ -88,15 +98,15 @@ async function scanForTextPowerPoint(result) {
         }
         return;
     }
-    else if(typeof(result) == "object") {
+    else if (typeof(result) == "object") {
         for (var property in result) {
             if (result.hasOwnProperty(property)) {
-                if (typeof(result[property]) == "string"){
+                if (typeof(result[property]) == "string") {
                     if ((property == "a:t" || property == "_") && result[property] != "") {
                         await myTextPowerPoint.push(result[property]);
                     }
                 }
-                else if (typeof(result[property][0]) == "string"){
+                else if (typeof(result[property][0]) == "string") {
                     if ((property == "a:t" || property == "_") && result[property] != "") {
                         await myTextPowerPoint.push(result[property]);
                     }
@@ -110,47 +120,55 @@ async function scanForTextPowerPoint(result) {
     }
 }
 
-
-var parsePowerPoint = function(filename, callback, deleteOfficeDist = true) {
+var parsePowerPoint = function (filename, callback, deleteOfficeDist = true) {
     if (validateFileExtension(filename, ["pptx"])) {
-        decompress(filename, decompressLocation).then(async files => {
-            myTextPowerPoint = [];
-
-            if (fs.existsSync(decompressLocation + '/ppt/slides')) {
-                var slidesNum = await fs.readdirSync(decompressLocation + '/ppt/slides').length;
-                
-
-                for (var i=0; i<slidesNum-1; i++) {
-                    var parser = new xml2js.Parser();
-
-                    var myData = await util.promisify(fs.readFile)(`${decompressLocation}/ppt/slides/slide${i+1}.xml`, 'utf8');
-                    var result = await util.promisify(parser.parseString.bind(parser))(myData);
-                    await scanForTextPowerPoint(result);
-                }
-
-                if (fs.existsSync(decompressLocation + '/ppt/notesSlides')) {
-                    var notesSlidesNum = await fs.readdirSync(decompressLocation + '/ppt/notesSlides').length;
-                    for (var i=0; i<notesSlidesNum-1; i++) {
+        try {
+            decompress(filename, decompressLocation).then(async files => {
+                myTextPowerPoint = [];
+    
+                if (fs.existsSync(decompressLocation + '/ppt/slides')) {
+                    var slidesNum = await fs.readdirSync(decompressLocation + '/ppt/slides').length;
+    
+                    for (var i = 0; i < slidesNum - 1; i++) {
                         var parser = new xml2js.Parser();
     
-                        var myData = await util.promisify(fs.readFile)(`${decompressLocation}/ppt/notesSlides/notesSlide${i+1}.xml`, 'utf8');
+                        var myData = await util.promisify(fs.readFile)(`${decompressLocation}/ppt/slides/slide${i + 1}.xml`, 'utf8');
                         var result = await util.promisify(parser.parseString.bind(parser))(myData);
                         await scanForTextPowerPoint(result);
                     }
-                }
-                
-                callback(myTextPowerPoint.join(" "));
+    
+                    if (fs.existsSync(decompressLocation + '/ppt/notesSlides')) {
+                        var notesSlidesNum = await fs.readdirSync(decompressLocation + '/ppt/notesSlides').length;
+                        for (var i = 0; i < notesSlidesNum - 1; i++) {
+                            var parser = new xml2js.Parser();
+        
+                            var myData = await util.promisify(fs.readFile)(`${decompressLocation}/ppt/notesSlides/notesSlide${i + 1}.xml`, 'utf8');
+                            var result = await util.promisify(parser.parseString.bind(parser))(myData);
+                            await scanForTextPowerPoint(result);
+                        }
+                    }
                     
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
+                    callback(myTextPowerPoint.join(" "), undefined);
+    
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
+                    }
                 }
-            }
-            else {
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
+                else {
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
+                    }
                 }
-            }
-        });
+            })
+            .catch(function (err) {
+                if (outputToConsoleWhenRequired) console.log(err);
+                return callback(undefined, err);
+            });
+        }
+        catch (err) {
+            if (outputToConsoleWhenRequired) console.log(err);
+            return callback(undefined, err);
+        }
     }
 } 
 
@@ -173,15 +191,15 @@ async function scanForTextExcelDrawing(result) {
         }
         return;
     }
-    else if(typeof(result) == "object") {
+    else if (typeof(result) == "object") {
         for (var property in result) {
             if (result.hasOwnProperty(property)) {
-                if (typeof(result[property]) == "string"){
+                if (typeof(result[property]) == "string") {
                     if ((property == "a:t" || property == "_") && result[property] != "") {
                         await myTextExcel.push(result[property]);
                     }
                 }
-                else if (typeof(result[property][0]) == "string"){
+                else if (typeof(result[property][0]) == "string") {
                     if ((property == "a:t" || property == "_") && result[property] != "") {
                         await myTextExcel.push(result[property]);
                     }
@@ -211,12 +229,12 @@ async function scanForTextExcelSharedStrings(result) {
     else if(typeof(result) == "object") {
         for (var property in result) {
             if (result.hasOwnProperty(property)) {
-                if (typeof(result[property]) == "string"){
+                if (typeof(result[property]) == "string") {
                     if ((property == "t" || property == "_") && result[property] != "") {
                         await myTextExcel.push(result[property]);
                     }
                 }
-                else if (typeof(result[property][0]) == "string"){
+                else if (typeof(result[property][0]) == "string") {
                     if ((property == "t" || property == "_") && result[property] != "") {
                         await myTextExcel.push(result[property]);
                     }
@@ -261,54 +279,64 @@ async function scanForTextExcelWorkSheet(result) {
     }
 }
 
-var parseExcel = function(filename, callback, deleteOfficeDist = true) {
+var parseExcel = function (filename, callback, deleteOfficeDist = true) {
     if (validateFileExtension(filename, ["xlsx"])) {
-        decompress(filename, decompressLocation).then(async files => {
-            myTextExcel = [];
-
-
-            if (fs.existsSync(decompressLocation + '/xl/worksheets')) {
-                var workSheetsNum = await fs.readdirSync(decompressLocation + '/xl/worksheets').length;
-                for (var i=0; i<workSheetsNum-1; i++) {
-                    var parser = new xml2js.Parser();
-
-                    var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/worksheets/sheet${i+1}.xml`, 'utf8');
-                    var result = await util.promisify(parser.parseString.bind(parser))(myData);
-                    await scanForTextExcelWorkSheet(result);
-                }
-
-                if (fs.existsSync(decompressLocation + '/xl/sharedStrings.xml')) {
-                    var parser = new xml2js.Parser();
-
-                    var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/sharedStrings.xml`, 'utf8');
-                    var result = await util.promisify(parser.parseString.bind(parser))(myData);
-                    await scanForTextExcelSharedStrings(result);
-                }
-            
-                if (fs.existsSync(decompressLocation + '/xl/drawings')) {
-                    var drawingsNum = await fs.readdirSync(decompressLocation + '/xl/drawings').length;
-
-                    for (var i=0; i<drawingsNum; i++) {
+        try {
+            decompress(filename, decompressLocation).then(async files => {
+                myTextExcel = [];
+    
+    
+                if (fs.existsSync(decompressLocation + '/xl/worksheets')) {
+                    var workSheetsNum = await fs.readdirSync(decompressLocation + '/xl/worksheets').length;
+                    for (var i = 0; i < workSheetsNum - 1; i++) {
                         var parser = new xml2js.Parser();
-
-                        var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/drawings/drawing${i+1}.xml`, 'utf8');
+    
+                        var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/worksheets/sheet${i + 1}.xml`, 'utf8');
                         var result = await util.promisify(parser.parseString.bind(parser))(myData);
-                        await scanForTextExcelDrawing(result);
+                        await scanForTextExcelWorkSheet(result);
+                    }
+    
+                    if (fs.existsSync(decompressLocation + '/xl/sharedStrings.xml')) {
+                        var parser = new xml2js.Parser();
+    
+                        var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/sharedStrings.xml`, 'utf8');
+                        var result = await util.promisify(parser.parseString.bind(parser))(myData);
+                        await scanForTextExcelSharedStrings(result);
+                    }
+    
+                    if (fs.existsSync(decompressLocation + '/xl/drawings')) {
+                        var drawingsNum = await fs.readdirSync(decompressLocation + '/xl/drawings').length;
+    
+                        for (var i = 0; i < drawingsNum; i++) {
+                            var parser = new xml2js.Parser();
+    
+                            var myData = await util.promisify(fs.readFile)(`${decompressLocation}/xl/drawings/drawing${i + 1}.xml`, 'utf8');
+                            var result = await util.promisify(parser.parseString.bind(parser))(myData);
+                            await scanForTextExcelDrawing(result);
+                        }
+                    }
+    
+                    callback(myTextExcel.join(" "), undefined);
+                    
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
                     }
                 }
-
-                callback(myTextExcel.join(" "));
-                
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
-                }
-            }
-            else {
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
+                else {
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
+                    }
                 }
-            }
-        });
+            })
+            .catch(function (err) {
+                if (outputToConsoleWhenRequired) console.log(err);
+                return callback(undefined, err);
+            });
+        }
+        catch (err) {
+            if (outputToConsoleWhenRequired) console.log(err);
+            return callback(undefined, err);
+        }
     }
 } 
 
@@ -332,10 +360,10 @@ async function scanForTextOpenOffice(result) {
         }
         return;
     }
-    else if(typeof(result) == "object") {
+    else if (typeof(result) == "object") {
         for (var property in result) {
             if (result.hasOwnProperty(property)) {
-                if (typeof(result[property]) == "string"){
+                if (typeof(result[property]) == "string") {
                     if (result[property] != "") {
                         await myTextOpenOffice.push(result[property]);
                     }
@@ -350,32 +378,43 @@ async function scanForTextOpenOffice(result) {
     }
 }
 
-var parseOpenOffice = async function(filename, callback, deleteOfficeDist = true) {
+var parseOpenOffice = async function (filename, callback, deleteOfficeDist = true) {
     if (validateFileExtension(filename, ["odt", "odp", "ods"])) {
-        decompress(filename, decompressLocation).then(files => {
-            myTextOpenOffice = [];
-            if (fs.existsSync(decompressLocation + "/content.xml")) {
-                fs.readFile(decompressLocation + '/content.xml', 'utf8', function (err,data) {
-                    if (err) {
-                       return console.log(err);
-                     }
-                     
-                     xml2js.parseString(data, {"ignoreAttrs": true}, async function (err, result) {
-                        await scanForTextOpenOffice(result);
-        
-                        callback(myTextOpenOffice.join(" "));
-                        if (deleteOfficeDist == true) {
-                            rimraf(decompressLocation, function () {});
+        try {
+            decompress(filename, decompressLocation).then(files => {
+                myTextOpenOffice = [];
+                if (fs.existsSync(decompressLocation + "/content.xml")) {
+                    fs.readFile(decompressLocation + '/content.xml', 'utf8', function (err,data) {
+                        if (err) {
+                            if (outputToConsoleWhenRequired) console.log(err);
+                            return callback(undefined, err);
                         }
-                     });
-                 });
-            }
-            else {
-                if (deleteOfficeDist == true) {
-                    rimraf(decompressLocation, function () {});
+                         
+                        xml2js.parseString(data, {"ignoreAttrs": true}, async function (err, result) {
+                            await scanForTextOpenOffice(result);
+    
+                            callback(myTextOpenOffice.join(" "), undefined);
+                            if (deleteOfficeDist == true) {
+                                rimraf(decompressLocation, function () {});
+                            }
+                        });
+                    });
                 }
-            }
-        });
+                else {
+                    if (deleteOfficeDist == true) {
+                        rimraf(decompressLocation, function () {});
+                    }
+                }
+            })
+            .catch(function (err) {
+                if (outputToConsoleWhenRequired) console.log(err);
+                return callback(undefined, err);
+            });
+        }
+        catch (err) {
+            if (outputToConsoleWhenRequired) console.log(err);
+            return callback(undefined, err);
+        }
     }
 }
 
@@ -386,13 +425,18 @@ var parseOpenOffice = async function(filename, callback, deleteOfficeDist = true
 
 // #region validate file names
 
+/**
+ * Legacy method to check whether file functions called are indeed applicable with files provided
+ * @param {*} filename file path
+ * @param {*} extension extensions of supported files
+ */
 function validateFileExtension(filename, extension) {
     for (var extensionIterator = 0; extensionIterator < extension.length; extensionIterator++) {
         if (extension[extensionIterator] == filename.split(".").pop().toLowerCase()) {
             return true;
         }
     }
-    console.log(`Sorry, we currently support docx, pptx, xlsx, odt, odp, ods files only. Make sure you pass appropriate file with the parsing functions.`);
+    console.log(`[OfficeParser]: Sorry, we currently support docx, pptx, xlsx, odt, odp, ods files only. Make sure you pass appropriate file with the parsing functions.`);
     return false;
 }
 
@@ -424,7 +468,9 @@ function parseOffice(filename, callback, deleteOfficeDist = true) {
         }, deleteOfficeDist);
     }
     else {
-        console.log(`Sorry, we currently support docx, pptx, xlsx, odt, odp, ods files only. Create a ticket in Issues on github to add support for ${extension} files. Stay tuned for further updates.`);
+        var errMessage = `[OfficeParser]: Sorry, we currently support docx, pptx, xlsx, odt, odp, ods files only. Create a ticket in Issues on github to add support for ${extension} files. Stay tuned for further updates.`;
+        if (outputToConsoleWhenRequired) console.log(errMessage);
+        return callback(undefined, errMessage);
     }
     
 }
@@ -434,16 +480,104 @@ function parseOffice(filename, callback, deleteOfficeDist = true) {
 
 // #region setDecompressionLocation
 function setDecompressionLocation(newLocation) {
-    decompressLocation = newLocation + "/officeDist";
+    if (newLocation != undefined) {
+        decompressLocation = newLocation + "/officeDist";
+    }
+    else {
+        decompressLocation = "officeDist";
+    }
 }
 
 // #endregion setDecompressionLocation
 
+// #region setConsoleOutput
+function enableConsoleOutput() {
+    outputToConsoleWhenRequired = true;
+}
+
+function disableConsoleOutput() {
+    outputToConsoleWhenRequired = false;
+}
+
+// #endregion setConsoleOutput
+
+// #region Async Versions
+var parseWordAsync = function (filename, deleteOfficeDist = true) {
+    return new Promise((resolve, reject) => {
+        try {
+            parseWord(filename, function (data, err) {
+                if (err) return reject(err);
+                return resolve(data);
+            },deleteOfficeDist);
+        } catch (error) {
+            return reject(error);
+        }
+    })
+}
 
+var parsePowerPointAsync = function (filename, deleteOfficeDist = true) {
+    return new Promise((resolve, reject) => {
+        try {
+            parsePowerPoint(filename, function (data, err) {
+                if (err) return reject(err);
+                return resolve(data);
+            },deleteOfficeDist);
+        } catch (error) {
+            return reject(error);
+        }
+    })
+}
+
+var parseExcelAsync = function (filename, deleteOfficeDist = true) {
+    return new Promise((resolve, reject) => {
+        try {
+            parseExcel(filename, function (data, err) {
+                if (err) return reject(err);
+                return resolve(data);
+            },deleteOfficeDist);
+        } catch (error) {
+            return reject(error);
+        }
+    })
+}
+
+var parseOpenOfficeAsync = function (filename, deleteOfficeDist = true) {
+    return new Promise((resolve, reject) => {
+        try {
+            parseOpenOffice(filename, function (data, err) {
+                if (err) return reject(err);
+                return resolve(data);
+            },deleteOfficeDist);
+        } catch (error) {
+            return reject(error);
+        }
+    })
+}
+
+var parseOfficeAsync = function (filename, deleteOfficeDist = true) {
+    return new Promise((resolve, reject) => {
+        try {
+            parseOffice(filename, function (data, err) {
+                if (err) return reject(err);
+                return resolve(data);
+            },deleteOfficeDist);
+        } catch (error) {
+            return reject(error);
+        }
+    })
+}
+// #endregion Async Versions
 
 module.exports.parseWord = parseWord;
 module.exports.parsePowerPoint = parsePowerPoint;
 module.exports.parseExcel = parseExcel;
 module.exports.parseOpenOffice = parseOpenOffice;
 module.exports.parseOffice = parseOffice;
+module.exports.parseWordAsync = parseWordAsync;
+module.exports.parsePowerPointAsync = parsePowerPointAsync;
+module.exports.parseExcelAsync = parseExcelAsync;
+module.exports.parseOpenOfficeAsync = parseOpenOfficeAsync;
+module.exports.parseOfficeAsync = parseOfficeAsync;
 module.exports.setDecompressionLocation = setDecompressionLocation;
+module.exports.enableConsoleOutput = enableConsoleOutput;
+module.exports.disableConsoleOutput = disableConsoleOutput;

package/package.json

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