@jtff/miztemplate-lib 3.0.0-rc2 → 3.0.0-rc22

package/lib/mizlib.js

@@ -7,331 +7,432 @@ const {promisify} = require("util");
 const fs = require("fs");
 const lstat = promisify(fs.lstat);
 
-function injectLuaScriptsInMissionObject(tObject, trObject, mrObject, strTitle, scriptFilesArray, timingInSeconds, hexColor) {
-    let nextIndex = Object.keys(trObject).length + 1;
-    if (nextIndex === 1) {
-        tObject['actions'] = {};
-        tObject['func'] = {};
-        tObject['conditions'] = {};
-        tObject['flag'] = {};
-        trObject = {};
+class Mizlib {
+    constructor() {
+        // no need for initialization
     }
-    let actionSentence = "";
-    let actionsObject = {};
-    for (const [index, scriptFile] of scriptFilesArray.entries()) {
-        actionSentence += "a_do_script_file(getValueResourceByKey(\"" + scriptFile + "\")); "
-        actionsObject[index + 1] = {
-            file: scriptFile,
-            predicate: 'a_do_script_file',
+
+    async injectLuaScriptIntoZipObjectAndUpdateWorkspace(workspacePath, folderPath, luaScriptsArray, titleString, zipObject, timing, colorString, fromLibrary=true) {
+        let missionObject = await this.getMissionObjectFromZipObject(zipObject);
+        let mapResourceObject = await this.getMapResourceObjectFromZipObject(zipObject);
+        let tuple = this.injectLuaScriptAndUpdateWorkspace(workspacePath, folderPath, luaScriptsArray, titleString, missionObject, mapResourceObject, timing, colorString, fromLibrary);
+        for (let luaScript of luaScriptsArray) {
+            this.injectFileIntoZipObject(zipObject, [
+                    workspacePath,
+                    fromLibrary ? "/.workspace/" : "/",
+                    folderPath,
+                    "/",
+                    path.basename(luaScript)
+                ].join("")
+            );
+        }
+        return {tuple, zipObject};
+    }
+
+    injectLuaScriptAndUpdateWorkspace(workspacePath, folderPath, luaScriptsArray, titleString, missionObject, mapResourceObject, timing, colorString ,fromLibrary=true) {
+        let tuple = this.injectLuaScriptsInMissionObject(
+            missionObject['trig'],
+            missionObject['trigrules'],
+            mapResourceObject,
+            titleString,
+            luaScriptsArray,
+            timing,
+            colorString
+        );
+        for (let luaScript of luaScriptsArray) {
+            fs.cpSync(
+                [
+                    'node_modules/@jtff/miztemplate-lib/lua/',
+                    folderPath,
+                    '/',
+                    luaScript
+                ].join(""),
+                [
+                    workspacePath,
+                    fromLibrary ? "/.workspace/" : "/",
+                    folderPath,
+                    "/",
+                    path.basename(luaScript)
+                ].join(""),
+                {force: true}
+            );
+        }
+        return tuple;
+    }
+
+    injectLuaScriptsInMissionObject(tObject, trObject, mrObject, strTitle, scriptFilesArray, timingInSeconds, hexColor) {
+        let nextIndex = Object.keys(trObject).length + 1;
+        if (nextIndex === 1) {
+            tObject['actions'] = {};
+            tObject['func'] = {};
+            tObject['conditions'] = {};
+            tObject['flag'] = {};
+            trObject = {};
+        }
+        let actionSentence = "";
+        let actionsObject = {};
+        for (const [index, scriptFile] of scriptFilesArray.entries()) {
+            actionSentence += "a_do_script_file(getValueResourceByKey(\"" + scriptFile + "\")); "
+            actionsObject[index + 1] = {
+                file: scriptFile,
+                predicate: 'a_do_script_file',
+            };
+            mrObject[scriptFile] = scriptFile;
+        }
+        actionSentence += "mission.trig.func[" + nextIndex + "]=nil;"
+        tObject['actions'][nextIndex] = actionSentence;
+        tObject['func'][nextIndex] = "if mission.trig.conditions[" + nextIndex + "]() then mission.trig.actions[" + nextIndex + "]() end";
+        tObject['conditions'][nextIndex] = "return(c_time_after(" + timingInSeconds + ") )";
+        tObject['flag'][nextIndex] = true;
+        trObject[nextIndex] = {
+            rules: {
+                1: {
+                    coalitionlist: 'red',
+                    seconds: timingInSeconds,
+                    predicate: 'c_time_after',
+                    zone: ''
+                }
+            },
+            eventlist: '',
+            comment: strTitle,
+            actions: actionsObject,
+            predicate: 'triggerOnce',
+            colorItem: hexColor
         };
-        mrObject[scriptFile] = scriptFile;
+        return {tObject: tObject, trObject: trObject, mrObject: mrObject};
     }
-    actionSentence += "mission.trig.func[" + nextIndex + "]=nil;"
-    tObject['actions'][nextIndex] = actionSentence;
-    tObject['func'][nextIndex] = "if mission.trig.conditions[" + nextIndex + "]() then mission.trig.actions[" + nextIndex + "]() end";
-    tObject['conditions'][nextIndex] = "return(c_time_after(" + timingInSeconds + ") )";
-    tObject['flag'][nextIndex] = true;
-    trObject[nextIndex] = {
-        rules: {
-            1: {
-                coalitionlist: 'red',
-                seconds: timingInSeconds,
-                predicate: 'c_time_after',
-                zone: ''
+
+    async getZipObjectFromMizPath(mizPath) {
+        var MizFile = new jszip();
+        const mizData = fs.readFileSync(mizPath);
+        return MizFile.loadAsync(mizData);
+    }
+
+    async buildMizFileFromMizTemplate(mizPath, copyPath, singleMission= true) {
+        const zipObject = await this.getZipObjectFromMizPath(mizPath);
+        const missionObject = await this.getMissionObjectFromZipObject(zipObject);
+        const strTheatreSettings = missionObject.theatre;
+        const srcFiles = fs.readdirSync("node_modules/@jtff/miztemplate-lib/lua/src",{recursive: true})
+            .filter(filename => path.extname(filename).toLowerCase()==='.lua' && !(filename.startsWith('200-')));
+        const libFiles = fs.readdirSync("node_modules/@jtff/miztemplate-lib/lua/lib",{recursive: true})
+            .filter(filename => path.extname(filename).toLowerCase()==='.lua');
+        for (let file of srcFiles) {
+            console.log('updating src/' + file + ' from the miztemplate-lib');
+            fs.cpSync('node_modules/@jtff/miztemplate-lib/lua/src/' + file,
+                '.workspace/src/' + file,
+                {force: true}
+            );
+        }
+        for (let file of libFiles) {
+            console.log('updating lib/' + file + ' from the miztemplate-lib');
+            fs.cpSync('node_modules/@jtff/miztemplate-lib/lua/lib/' + file,
+                '.workspace/lib/' + file,
+                {force: true}
+            );
+        }
+        this.injectLuaFilesFromFolderIntoZipObject(zipObject, '.workspace/src');
+        this.injectLuaFilesFromFolderIntoZipObject(zipObject, '.workspace/lib');
+        this.injectLuaFilesFromFolderIntoZipObject(zipObject, 'src');
+        await this.injectRadioPresetsFromFolderIntoZipObject(zipObject, 'resources/radios/' + strTheatreSettings);
+        this.injectSettingsLuaFilesFromFolderIntoZipObject(zipObject, singleMission ? '' : strTheatreSettings);
+        await this.injectSoundFoldersIntoZipObject(zipObject);
+        const inputZip = await zipObject.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
             }
-        },
-        eventlist: '',
-        comment: strTitle,
-        actions: actionsObject,
-        predicate: 'triggerOnce',
-        colorItem: hexColor
-    };
-    return { tObject: tObject, trObject: trObject, mrObject: mrObject };
-}
+        });
+        fs.writeFileSync(copyPath ? copyPath : mizPath, inputZip);
+    }
 
-async function getZipObjectFromMizPath(mizPath) {
-    var MizFile = new jszip();
-    const mizData = fs.readFileSync(mizPath);
-    return MizFile.loadAsync(mizData);
-}
+    async injectMissionObjectIntoMizFile(mizPath, missionObject) {
+        const zip = this.injectMissionObjectIntoZipObject(await this.getZipObjectFromMizPath(mizPath), missionObject);
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, inputZip);
+    }
 
-async function mizUpdate(mizPath, copyPath, strTheatreSettings) {
-    const zip = await getZipObjectFromMizPath(mizPath);
-    injectLuaFilesFromFolderIntoZipObject(zip,'src');
-    injectLuaFilesFromFolderIntoZipObject(zip,'lib');
-    if (strTheatreSettings === null) {
-        // TODO: Inject fake data
-        console.log("NO THEATRE SPECIFIED. RADIO PRESETS WILL NOT BE AVAILABLE !");
-    } else {
-        await mizUpdateRadioPresets(zip, 'resources/radios/' + strTheatreSettings);
+    async injectLuaSettingsFromFolderPathToMizPath(mizPath, settingsFolder) {
+        const zip = await this.getZipObjectFromMizPath(mizPath);
+        await this.injectLuaSettingsFromFolderPathToZipObject(zip, settingsFolder);
+        const outputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, outputZip);
     }
-    mizUpdateSettingsLuaFiles(zip, strTheatreSettings);
-    await mizUpdateSoundFolders(zip);
-    const inputZip = await zip.generateAsync({
-        type: 'nodebuffer',
-        streamFiles: true,
-        compression: "DEFLATE",
-        compressionOptions: {
-            level: 9
-        }
-    });
-    fs.writeFileSync(copyPath ? copyPath : mizPath, inputZip);
-}
 
-async function mizInjectMissionDataFile(mizPath, missionObject) {
-    const zip = await getZipObjectFromMizPath(mizPath);
-    mizUpdateMissionDataFile(zip, missionObject);
-    const inputZip = await zip.generateAsync({
-        type: 'nodebuffer',
-        streamFiles: true,
-        compression: "DEFLATE",
-        compressionOptions: {
-            level: 9
+    async injectLuaSettingsFromFolderPathToZipObject(zip, settingsFolder) {
+        for (let file of fs.readdirSync(settingsFolder).filter(file => file.endsWith(".lua"))) {
+            this.injectFileIntoZipObject(zip, [
+                settingsFolder,
+                "/",
+                file].join(""));
         }
-    });
-    fs.writeFileSync(mizPath, inputZip);
-}
+    }
 
-async function injectLuaSettingsFromFolderPathToMizPath(mizPath, settingsFolder) {
-    const zip = await getZipObjectFromMizPath(mizPath);
-    await injectLuaSettingsFromFolderPathToZipObject(zip,settingsFolder);
-    const outputZip = await zip.generateAsync({
-        type: 'nodebuffer',
-        streamFiles: true,
-        compression: "DEFLATE",
-        compressionOptions: {
-            level: 9
-        }
-    });
-    fs.writeFileSync(mizPath, outputZip);
-}
 
-async function injectLuaSettingsFromFolderPathToZipObject(zip, settingsFolder) {
-    for (let file of fs.readdirSync(settingsFolder).filter(file => file.endsWith(".lua"))) {
-        injectFileIntoZipObject(zip, [
-            settingsFolder,
-            "/",
-            file].join(""));
+    async injectMapResourceObjectIntoMizFile(mizPath, mapResourceObject) {
+        const zip = await this.getZipObjectFromMizPath(mizPath);
+        this.injectMapResourceObjectIntoZipObject(zip, mapResourceObject);
+        const inputZip = await zip.generateAsync({
+            type: 'nodebuffer',
+            streamFiles: true,
+            compression: "DEFLATE",
+            compressionOptions: {
+                level: 9
+            }
+        });
+        fs.writeFileSync(mizPath, inputZip);
     }
-}
 
+    injectFileIntoZipObject(zip, filePath) {
+        zip.remove("l10n/DEFAULT/" + path.basename(filePath));
+        var stream = fs.createReadStream(filePath);
+        zip.file("l10n/DEFAULT/" + path.basename(filePath), stream);
+    }
 
-async function mizInjectMapResourceFile(mizPath, mapResourceObject) {
-    const zip = await getZipObjectFromMizPath(mizPath);
-    mizUpdateMapResourceFile(zip, mapResourceObject);
-    const inputZip = await zip.generateAsync({
-        type: 'nodebuffer',
-        streamFiles: true,
-        compression: "DEFLATE",
-        compressionOptions: {
-            level: 9
-        }
-    });
-    fs.writeFileSync(mizPath, inputZip);
-}
+    injectMissionObjectIntoZipObject(zip, missionObject) {
+        zip.remove("mission");
+        let missionLuaT = format(missionObject, {singleQuote: false})
+        missionLuaT = missionLuaT
+            .split('\n')
+            .slice(1, -1)
+            .join('\n')
+            .slice(0, -1)
+            .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
+        zip.file("mission", missionLuaT);
+    }
 
-function injectFileIntoZipObject(zip, filePath) {
-    zip.remove("l10n/DEFAULT/" + path.basename(filePath));
-    var stream = fs.createReadStream(filePath);
-    zip.file("l10n/DEFAULT/" + path.basename(filePath), stream);
-}
+    injectMapResourceObjectIntoZipObject(zip, mapResourceObject) {
+        zip.remove("l10n/DEFAULT/mapResource");
+        let mapResourceLuaT = format(mapResourceObject, {singleQuote: false})
+        mapResourceLuaT = mapResourceLuaT
+            .split('\n')
+            .slice(1, -1)
+            .join('\n')
+            .slice(0, -1)
+            .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
+        zip.file("l10n/DEFAULT/mapResource", mapResourceLuaT);
+    }
 
-function mizUpdateMissionDataFile(zip, missionObject) {
-    zip.remove("mission");
-    let missionLuaT = format(missionObject, { singleQuote: false })
-    missionLuaT = missionLuaT
-        .split('\n')
-        .slice(1, -1)
-        .join('\n')
-        .slice(0, -1)
-        .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
-    zip.file("mission", missionLuaT);
-}
+    getMissionLuaStringFromZipObject(zipStream) {
+        return zipStream.file("mission").async("string");
+    }
 
-function mizUpdateMapResourceFile(zip, mapResourceObject) {
-    zip.remove("l10n/DEFAULT/mapResource");
-    let mapResourceLuaT = format(mapResourceObject, { singleQuote: false })
-    mapResourceLuaT = mapResourceLuaT
-        .split('\n')
-        .slice(1, -1)
-        .join('\n')
-        .slice(0, -1)
-        .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
-    zip.file("l10n/DEFAULT/mapResource", mapResourceLuaT);
-}
+    getMapResourceLuaStringFromZipObject(zipStream) {
+        return zipStream.file("l10n/DEFAULT/mapResource").async("string");
+    }
 
-function getMissionLuaStringFromZipObject(zipStream) {
-    return zipStream.file("mission").async("string");
-}
+    injectLuaFilesFromFolderIntoZipObject(zip, folderPath) {
+        for (let file of fs.readdirSync(folderPath).filter(file => file.endsWith(".lua"))) {
+            console.log('injecting up2date ' + folderPath + '/' + file + ' file in archive');
+            this.injectFileIntoZipObject(zip, folderPath + "/" + file);
+        };
+    }
 
-function getMapResourceLuaStringFromZipObject(zipStream) {
-    return zipStream.file("l10n/DEFAULT/mapResource").async("string");
-}
 
-function injectLuaFilesFromFolderIntoZipObject(zip, folderPath) {
-    for (let file of fs.readdirSync(folderPath).filter(file => file.endsWith(".lua"))) {
-        console.log('injecting up2date ' + folderPath + '/' + file + ' file in archive');
-        injectFileIntoZipObject(zip, folderPath + "/" + file);
-    };
-}
+    async injectRadioPresetsFromFolderIntoZipObject(zip, preset_folder) {
+        // Create folder Avionics to make sure it exists then delete it to remove any old preset in the template
+        // Allows adding presets for A-10C
+        zip.folder("Avionics");
+        zip.remove("Avionics");
+
+        const mission_object = await this.getMissionObjectFromZipObject(zip);
+        for (let file of fs.readdirSync(preset_folder).filter(file => file.endsWith(".lua"))) {
+            const file_data = fs.readFileSync(preset_folder + '/' + file).toString();
+            const lua_string = file_data.substring(0, file_data.indexOf("radio_descriptor_table =") - 1);
+            const radio_descriptor_table = parse("return {" + lua_string + "}").descriptor;
 
+            console.log('updating radio presets (aircraft: ' + radio_descriptor_table["aircraft"] + ', group_name: ' + radio_descriptor_table["group_name"] + ') with preset in ' + preset_folder + ' folder');
+            const dcs_radio_presets = file_data.substring(file_data.indexOf("radio_descriptor_table =") + 24);
 
-async function mizUpdateRadioPresets(zip, preset_folder) {
-    // Create folder Avionics to make sure it exists then delete it to remove any old preset in the template
-    // Allows adding presets for A-10C
-    zip.folder("Avionics");
-    zip.remove("Avionics");
-
-    const mission_object = await getMissionObjectFromZipObject(zip);
-    for (let file of fs.readdirSync(preset_folder).filter(file => file.endsWith(".lua"))) {
-        const file_data = fs.readFileSync(preset_folder + '/' + file).toString();
-        const lua_string = file_data.substring(0, file_data.indexOf("radio_descriptor_table =") - 1);
-        const radio_descriptor_table = parse("return {" + lua_string + "}").descriptor;
-
-        console.log('updating radio presets (aircraft: ' + radio_descriptor_table["aircraft"] + ', group_name: ' + radio_descriptor_table["group_name"] + ') with preset in ' + preset_folder + ' folder');
-        const dcs_radio_presets = file_data.substring(file_data.indexOf("radio_descriptor_table =") + 24);
-
-        for (const coalition_key in mission_object.coalition) {
-            const coalition = mission_object.coalition[coalition_key];
-            for (const country_list_key in coalition) {
-                if (country_list_key != "country") continue;
-                const country_list = coalition[country_list_key];
-                for (const country_key in country_list) {
-                    const country = country_list[country_key];
-                    for (const plane_key in country["plane"]) {
-                        const plane = country["plane"][plane_key];
-                        for (const group_key in plane) {
-                            const group = plane[group_key];
-                            if (group["name"].match(radio_descriptor_table["group_name"]) == null) continue;
-                            for (const unit_key in group) {
-                                if (unit_key != "units") continue;
-                                const unit = group[unit_key];
-                                for (const sub_unit_key in unit) {
-                                    const sub_unit = unit[sub_unit_key];
-                                    if (sub_unit["skill"] != "Client") continue;
-                                    // Aircraft is an A10CII, use A10C mode by creating files in the root with the unit id
-                                    // if (radio_descriptor_table["aircraft"] == 'A-10C_2') {
-                                    //     const unit_id = sub_unit["unitId"];
-                                    //     ["UHF_RADIO", "VHF_AM_RADIO", "VHF_FM_RADIO"].forEach(folder => {
-                                    //         var zip_folder = zip.folder("Avionics/A-10C_2/" + unit_id + "/" + folder);
-                                    //         var file = parse("return " + dcs_radio_presets)[folder];
-                                    //         file = format(file, { singleQuote: false });
-                                    //         file = file
-                                    //             .split('\n')
-                                    //             .slice(1, -1)
-                                    //             .join('\n')
-                                    //             .slice(0, -1)
-                                    //             .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
-                                    //         zip_folder.file("SETTINGS.lua", file);
-                                    //     });
-                                    //     continue;
-                                    // }
-                                    if (sub_unit["type"] != radio_descriptor_table["aircraft"]) continue;
-                                    // GROUP FOUND, SET RADIOS
-                                    sub_unit["Radio"] = parse("return " + dcs_radio_presets)
+            for (const coalition_key in mission_object.coalition) {
+                const coalition = mission_object.coalition[coalition_key];
+                for (const country_list_key in coalition) {
+                    if (country_list_key != "country") continue;
+                    const country_list = coalition[country_list_key];
+                    for (const country_key in country_list) {
+                        const country = country_list[country_key];
+                        for (const plane_key in country["plane"]) {
+                            const plane = country["plane"][plane_key];
+                            for (const group_key in plane) {
+                                const group = plane[group_key];
+                                if (group["name"].match(radio_descriptor_table["group_name"]) == null) continue;
+                                for (const unit_key in group) {
+                                    if (unit_key != "units") continue;
+                                    const unit = group[unit_key];
+                                    for (const sub_unit_key in unit) {
+                                        const sub_unit = unit[sub_unit_key];
+                                        if (sub_unit["skill"] != "Client") continue;
+                                        // Aircraft is an A10CII, use A10C mode by creating files in the root with the unit id
+                                        // if (radio_descriptor_table["aircraft"] == 'A-10C_2') {
+                                        //     const unit_id = sub_unit["unitId"];
+                                        //     ["UHF_RADIO", "VHF_AM_RADIO", "VHF_FM_RADIO"].forEach(folder => {
+                                        //         var zip_folder = zip.folder("Avionics/A-10C_2/" + unit_id + "/" + folder);
+                                        //         var file = parse("return " + dcs_radio_presets)[folder];
+                                        //         file = format(file, { singleQuote: false });
+                                        //         file = file
+                                        //             .split('\n')
+                                        //             .slice(1, -1)
+                                        //             .join('\n')
+                                        //             .slice(0, -1)
+                                        //             .replace(/\[\"(\d+)\"\] = /g, "[$1] = ");
+                                        //         zip_folder.file("SETTINGS.lua", file);
+                                        //     });
+                                        //     continue;
+                                        // }
+                                        if (sub_unit["type"] != radio_descriptor_table["aircraft"]) continue;
+                                        // GROUP FOUND, SET RADIOS
+                                        sub_unit["Radio"] = parse("return " + dcs_radio_presets)
+                                    }
                                 }
                             }
                         }
                     }
                 }
             }
-        }
-    };
-    mizUpdateMissionDataFile(zip, {mission: mission_object});
-}
+        };
+        this.injectMissionObjectIntoZipObject(zip, {mission: mission_object});
+    }
 
-function mizUpdateSettingsLuaFiles(zip, strTheatre) {
-    for (let file of fs.readdirSync('settings/' + strTheatre).filter(file => file.endsWith(".lua"))) {
-        console.log('updating settings/' + strTheatre + '/' + file + ' file in miz file');
-        injectFileIntoZipObject(zip, 'settings/' + strTheatre + '/' + file);
-    };
-}
+    injectSettingsLuaFilesFromFolderIntoZipObject(zip, strTheatre) {
+        for (let file of fs.readdirSync(['settings',strTheatre.length > 0 ? '/' + strTheatre : ''].join('')).filter(file => path.extname(file).toLowerCase()==='.lua')) {
+            console.log(['updating settings',strTheatre.length > 0 ? '/' + strTheatre : '','/',file,' file in miz file'].join(''));
+            this.injectFileIntoZipObject(zip, ['settings',strTheatre.length > 0 ? '/' + strTheatre : '','/',file].join(''));
+        }
+    }
 
-async function mizUpdateSoundFolders(zip) {
-    if (fs.existsSync('resources/sounds') && fs.lstatSync('resources/sounds').isDirectory()) {
-        const folderArray = fs.readdirSync('resources/sounds');
-        for (const folder of folderArray) {
-            await mizUpdateSingleSoundFolder(zip, folder);
+    async injectSoundFoldersIntoZipObject(zip) {
+        if (fs.existsSync('resources/sounds') && fs.lstatSync('resources/sounds').isDirectory()) {
+            const folderArray = fs.readdirSync('resources/sounds');
+            for (const folder of folderArray) {
+                await this.injectSingleSoundFolderIntoZipObject(zip, '.', folder, false);
+            }
+        }
+        if (fs.existsSync('.workspace/resources/sounds') && fs.lstatSync('.workspace/resources/sounds').isDirectory()) {
+            const folderArray = fs.readdirSync('.workspace/resources/sounds');
+            for (const folder of folderArray) {
+                await this.injectSingleSoundFolderIntoZipObject(zip, '.', folder, true);
+            }
         }
     }
-}
 
-async function mizUpdateSingleSoundFolder(zip, folder) {
-    if (fs.existsSync('resources/sounds/' + folder) && fs.lstatSync('resources/sounds/' + folder).isDirectory()) {
-        console.log('adding sound files from resources/sounds/' + folder + ' folder...');
-        zip = zip.remove(folder).folder(folder);
-        await addFilesToZip(zip, 'resources/sounds/' + folder, fs.readdirSync('resources/sounds/' + folder));
+    async updateWorkspaceWithSingleSoundFolder(workspacePath, folderString) {
+        if (
+            fs.existsSync(
+                [
+                    workspacePath,
+                    "/.workspace/resources/sounds/",
+                    folderString
+                ].join("")
+            ) &&
+            fs.lstatSync([
+                workspacePath,
+                "/.workspace/resources/sounds/",
+                folderString
+            ].join("")).isDirectory()
+        ) {
+            fs.rmSync([
+                workspacePath,
+                "/.workspace/resources/sounds/",
+                folderString
+            ].join(""), {recursive: true});
+        }
+        if (
+            fs.existsSync('node_modules/@jtff/miztemplate-lib/resources/sounds/' + folderString) &&
+            fs.lstatSync('node_modules/@jtff/miztemplate-lib/resources/sounds/' + folderString).isDirectory()) {
+            fs.mkdirSync([
+                workspacePath,
+                "/.workspace/resources/sounds/",
+                folderString
+            ].join(""), {recursive: true});
+            fs.cpSync('node_modules/@jtff/miztemplate-lib/resources/sounds/' + folderString,[
+                workspacePath,
+                "/.workspace/resources/sounds/",
+                folderString
+            ].join(""), {recursive: true});
+        }
     }
-}
 
-async function addFilesToZip(zip, directoryPath, filesToInclude) {
-    const promiseArr = await filesToInclude.map(async file => {
-        const filePath = path.join(directoryPath, file)
-        try {
-            const fileStats = await lstat(filePath)
-            const isDirectory = fileStats.isDirectory()
-            if (isDirectory) {
-                const directory = zip.remove(file).folder(file)
-                const subFiles = fs.readdirSync(filePath)
-                return addFilesToZip(directory, filePath, subFiles)
-            } else {
-                // console.log('added file : '+file);
-                return zip.file(file, fs.createReadStream(filePath))
+    async injectSingleSoundFolderIntoZipObject(zip, workspacePath, folder, fromLibrary = true) {
+        if (
+            fs.existsSync([workspacePath,fromLibrary? '/.workspace/resources/sounds/'+folder : '/resources/sounds'].join('')) &&
+            fs.lstatSync([workspacePath,fromLibrary? '/.workspace/resources/sounds/'+folder : '/resources/sounds'].join('')).isDirectory()) {
+            console.log(['adding sound files from ',workspacePath,fromLibrary? '/.workspace/resources/sounds/'+folder : '/resources/sounds',' folder...'].join(''));
+            if (fromLibrary) {
+                zip = zip.remove(folder).folder(folder);
             }
-        } catch (err) {
-            console.log(err)
-            return Promise.resolve()
+            await this.addFilesToZip(
+                zip,
+                [workspacePath,fromLibrary? '/.workspace/resources/sounds/'+folder : '/resources/sounds'].join(''),
+                fs.readdirSync([workspacePath,fromLibrary? '/.workspace/resources/sounds/'+folder : '/resources/sounds'].join('')));
         }
-    })
-    return Promise.all(promiseArr)
-}
+    }
 
-async function copyMiz(srcMizPath, dstMizPath) {
-    await fs.createReadStream(srcMizPath).pipe(fs.createWriteStream(dstMizPath));
-}
+    async addFilesToZip(zip, directoryPath, filesToInclude) {
+        const promiseArr = await filesToInclude.map(async file => {
+            const filePath = path.join(directoryPath, file)
+            try {
+                const fileStats = await lstat(filePath)
+                const isDirectory = fileStats.isDirectory()
+                if (isDirectory) {
+                    const directory = zip.remove(file).folder(file)
+                    const subFiles = fs.readdirSync(filePath)
+                    return this.addFilesToZip(directory, filePath, subFiles)
+                } else {
+                    // console.log('added file : '+file);
+                    return zip.file(file, fs.createReadStream(filePath))
+                }
+            } catch (err) {
+                console.log(err)
+                return Promise.resolve()
+            }
+        })
+        return Promise.all(promiseArr)
+    }
 
-async function getMissionObjectFromMizPath(MizPath) {
-    let luaTable = 'return { \n' + await getMissionLuaStringFromZipObject(await getZipObjectFromMizPath(MizPath)) + ' }';
-    return parse(luaTable).mission;
-}
+    async copyMiz(srcMizPath, dstMizPath) {
+        await fs.createReadStream(srcMizPath).pipe(fs.createWriteStream(dstMizPath));
+    }
 
-async function getMissionObjectFromZipObject(zip) {
-    let luaTable = 'return { \n' + await getMissionLuaStringFromZipObject(zip) + ' }';
-    return parse(luaTable).mission;
-}
+    async getMissionObjectFromMizPath(MizPath) {
+        let luaTable = 'return { \n' + await this.getMissionLuaStringFromZipObject(await this.getZipObjectFromMizPath(MizPath)) + ' }';
+        return parse(luaTable).mission;
+    }
 
-async function getMapResourceObjectFromMizPath(MizPath) {
-    let luaTable = 'return { \n' + await getMapResourceLuaStringFromZipObject(await getZipObjectFromMizPath(MizPath)) + ' }';
-    return parse(luaTable).mapResource;
-}
+    async getMissionObjectFromZipObject(zip) {
+        let luaTable = 'return { \n' + await this.getMissionLuaStringFromZipObject(zip) + ' }';
+        return parse(luaTable).mission;
+    }
 
-async function getMapResourceObjectFromZipObject(zip) {
-    let luaTable = 'return { \n' + await getMapResourceLuaStringFromZipObject(zip) + ' }';
-    return parse(luaTable).mapResource;
+    async getMapResourceObjectFromMizPath(MizPath) {
+        let luaTable = 'return { \n' + await this.getMapResourceLuaStringFromZipObject(await this.getZipObjectFromMizPath(MizPath)) + ' }';
+        return parse(luaTable).mapResource;
+    }
+
+    async getMapResourceObjectFromZipObject(zip) {
+        let luaTable = 'return { \n' + await this.getMapResourceLuaStringFromZipObject(zip) + ' }';
+        let mrObject = parse(luaTable).mapResource;
+        if (Array.isArray(mrObject)) {
+            if (mrObject.length === 0) {
+                mrObject = {};
+            }
+        }
+        return mrObject;
+    }
 }
 
-module.exports = {
-    injectLuaScriptsInMissionObject: injectLuaScriptsInMissionObject,
-    getZipObjectFromMizPath: getZipObjectFromMizPath,
-    mizUpdate: mizUpdate,
-    mizInjectMissionDataFile: mizInjectMissionDataFile,
-    injectLuaSettingsFromFolderPathToMizPath: injectLuaSettingsFromFolderPathToMizPath,
-    injectLuaSettingsFromFolderPathToZipObject: injectLuaSettingsFromFolderPathToZipObject,
-    mizInjectMapResourceFile: mizInjectMapResourceFile,
-    injectFileIntoZipObject: injectFileIntoZipObject,
-    mizUpdateMissionDataFile: mizUpdateMissionDataFile,
-    mizUpdateMapResourceFile: mizUpdateMapResourceFile,
-    getMissionLuaStringFromZipObject: getMissionLuaStringFromZipObject,
-    getMapResourceLuaStringFromZipObject: getMapResourceLuaStringFromZipObject,
-    mizUpdateRadioPresets: mizUpdateRadioPresets,
-    mizUpdateSettingsLuaFiles: mizUpdateSettingsLuaFiles,
-    mizUpdateSoundFolders: mizUpdateSoundFolders,
-    mizUpdateSingleSoundFolder: mizUpdateSingleSoundFolder,
-    addFilesToZip: addFilesToZip,
-    copyMiz: copyMiz,
-    getMissionObjectFromMizPath: getMissionObjectFromMizPath,
-    getMissionObjectFromZipObject: getMissionObjectFromZipObject,
-    getMapResourceObjectFromMizPath: getMapResourceObjectFromMizPath,
-    getMapResourceObjectFromZipObject: getMapResourceObjectFromZipObject,
-    injectLuaFilesFromFolderIntoZipObject: injectLuaFilesFromFolderIntoZipObject
-};
+module.exports = Mizlib;